@gtkx/ffi 0.7.0 → 0.9.0

package/dist/generated/glib/functions.d.ts

@@ -1,5 +1,5 @@
 import { Ref } from "@gtkx/native";
-import { ChecksumType, DateWeekday, FileError, FileSetContentsFlags, FileTest, FormatSizeFlags, IOChannelError, IOCondition, LogLevelFlags, LogWriterOutput, NormalizeMode, RegexCompileFlags, RegexMatchFlags, SliceConfig, SpawnFlags, TestFileType, TestLogType, TestSubprocessFlags, TestTrapFlags, UnicodeBreakType, UnicodeScript, UnicodeType, UriFlags, UriParamsFlags, UserDirectory } from "./enums.js";
+import { ChecksumType, DateWeekday, FileError, FileSetContentsFlags, FileTest, FormatSizeFlags, IOChannelError, IOCondition, LogLevelFlags, LogWriterOutput, NormalizeMode, RegexCompileFlags, RegexMatchFlags, SliceConfig, TestFileType, TestLogType, TestSubprocessFlags, TestTrapFlags, UnicodeBreakType, UnicodeScript, UnicodeType, UriFlags, UriParamsFlags, UserDirectory } from "./enums.js";
 import { ByteArray } from "./byte-array.js";
 import { Bytes } from "./bytes.js";
 import { Date } from "./date.js";
@@ -368,40 +368,6 @@ export declare const asyncQueueNew: () => number;
  * @param itemFreeFunc - function to free queue elements
  */
 export declare const asyncQueueNewFull: (itemFreeFunc?: () => void | null) => number;
-/**
- * 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.
- */
-export declare const atexit: (func: (...args: unknown[]) => unknown) => void;
 /**
  * Atomically adds `val` to the value of @atomic.
  *
@@ -1101,29 +1067,6 @@ export declare const byteArraySetSize: (array: ByteArray, length: number) => Byt
  * @param reservedSize - the number of bytes preallocated
  */
 export declare const byteArraySizedNew: (reservedSize: number) => ByteArray;
-/**
- * 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 byte array
- * @param compareFunc - the comparison function
- */
-export declare const byteArraySort: (array: ByteArray, compareFunc: (...args: unknown[]) => unknown) => void;
-/**
- * Like [func@GLib.ByteArray.sort], but the comparison function takes an extra
- * user data argument.
- * @param array - a byte array
- * @param compareFunc - the comparison function
- * @param userData - the data to pass to @compare_func
- */
-export declare const byteArraySortWithData: (array: ByteArray, compareFunc: (a: unknown, b: unknown) => number) => void;
 /**
  * Frees the data in the array and resets the size to zero, while
  * the underlying array is preserved for use elsewhere and returned
@@ -1192,38 +1135,6 @@ export declare const checkVersion: (requiredMajor: number, requiredMinor: number
  * @param checksumType - a #GChecksumType
  */
 export declare const 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 [func@GLib.spawn_async] or
- * [func@GLib.spawn_async_with_pipes] you will need to pass
- * [flags@GLib.SpawnFlags.DO_NOT_REAP_CHILD] as a flag to the spawn function for
- * the child watching to work.
- *
- * In many programs, you will want to call [func@GLib.spawn_check_wait_status]
- * in the callback to determine whether or not the child exited
- * successfully.
- *
- * Also, note that on platforms where [type@GLib.Pid] must be explicitly closed
- * (see [func@GLib.spawn_close_pid]) `pid` must not be closed while the source
- * is still active.  Typically, you should invoke [func@GLib.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
- * [func@GLib.child_watch_source_new] apply to this function.
- *
- * This internally creates a main loop source using
- * [func@GLib.child_watch_source_new] and attaches it to the main loop context
- * using [method@GLib.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
- * @param pid - process to watch — on POSIX systems, this is the positive PID of a
- * @param _function - function to call
- * @param data - data to pass to @function
- * @param notify - function to call when the idle is removed
- */
-export declare const childWatchAddFull: (priority: number, pid: number, _function: (...args: unknown[]) => unknown, data?: number | null, notify?: () => void | null) => number;
 /**
  * Creates a new child watch source.
  *
@@ -1466,22 +1377,6 @@ export declare const convertWithFallback: (str: number[], len: number, toCodeset
  * @param mode - as in creat()
  */
 export declare const 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.
- * @param userData - user data to pass to the function.
- */
-export declare const datalistForeach: (datalist: number, func: (...args: unknown[]) => unknown, userData?: number | null) => void;
 /**
  * Gets a data element, using its string identifier. This is slower than
  * g_datalist_id_get_data() because it compares strings.
@@ -1537,20 +1432,6 @@ export declare const datalistUnsetFlags: (datalist: number, flags: number) => vo
  * @param datasetLocation - the location identifying the dataset.
  */
 export declare const datasetDestroy: (datasetLocation: number) => 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.
- * @param userData - user data to pass to the function.
- */
-export declare const datasetForeach: (datasetLocation: number, func: (...args: unknown[]) => unknown, userData?: number | null) => void;
 /**
  * Gets the data element corresponding to a #GQuark.
  * @param datasetLocation - the location identifying the dataset.
@@ -1841,42 +1722,6 @@ export declare const environSetenv: (variable: string, value: string, overwrite:
  * @param variable - the environment variable to remove, must not
  */
 export declare const environUnsetenv: (variable: string, envp?: string[] | null) => 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
- */
-export declare const errorDomainRegister: (errorTypeName: string, errorTypePrivateSize: number, errorTypeInit: (...args: unknown[]) => unknown, errorTypeCopy: (...args: unknown[]) => unknown, errorTypeClear: (...args: unknown[]) => unknown) => number;
-/**
- * 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
- */
-export declare const errorDomainRegisterStatic: (errorTypeName: string, errorTypePrivateSize: number, errorTypeInit: (...args: unknown[]) => unknown, errorTypeCopy: (...args: unknown[]) => unknown, errorTypeClear: (...args: unknown[]) => unknown) => number;
 /**
  * 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.
@@ -2859,70 +2704,6 @@ export declare const hashTableContains: (hashTable: HashTable, key?: number | nu
  * @param hashTable - a #GHashTable
  */
 export declare const 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
- * @param userData - user data to pass to the function
- */
-export declare const hashTableFind: (hashTable: HashTable, predicate: (...args: unknown[]) => unknown, userData?: number | null) => number | 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
- * @param userData - user data to pass to the function
- */
-export declare const hashTableForeach: (hashTable: HashTable, func: (...args: unknown[]) => unknown, userData?: number | null) => 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
- * @param userData - user data to pass to the function
- */
-export declare const hashTableForeachRemove: (hashTable: HashTable, func: (...args: unknown[]) => unknown, userData?: number | null) => 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
- * @param userData - user data to pass to the function
- */
-export declare const hashTableForeachSteal: (hashTable: HashTable, func: (...args: unknown[]) => unknown, userData?: number | null) => number;
 /**
  * Inserts a new key and value into a #GHashTable.
  *
@@ -3098,13 +2879,6 @@ export declare const hookFree: (hookList: number, hook: number) => void;
  * @param hook - the #GHook to insert
  */
 export declare const hookInsertBefore: (hookList: number, hook: number, sibling?: number | null) => 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
- */
-export declare const hookInsertSorted: (hookList: number, hook: number, func: (...args: unknown[]) => unknown) => void;
 /**
  * Prepends a #GHook on the start of a #GHookList.
  * @param hookList - a #GHookList
@@ -3168,27 +2942,6 @@ export declare const hostnameToAscii: (hostname: string) => string | null;
  * @param hostname - a valid UTF-8 or ASCII hostname
  */
 export declare const hostnameToUnicode: (hostname: string) => string | null;
-/**
- * Adds a function to be called whenever there are no higher priority
- * events pending.
- *
- * If the function returns [const@GLib.SOURCE_REMOVE] it is automatically
- * removed from the list of event sources and will not be called again.
- *
- * See main loop memory management for details
- * on how to handle the return value and memory management of @data.
- *
- * This internally creates a main loop source using [func@GLib.idle_source_new]
- * and attaches it to the global [struct@GLib.MainContext] using
- * [method@GLib.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
- * @param _function - function to call
- * @param data - data to pass to @function
- * @param notify - function to call when the idle is removed
- */
-export declare const idleAddFull: (priority: number, _function: () => boolean, data?: number | null, notify?: () => void | null) => number;
 /**
  * Removes the idle function with the given data.
  * @param data - the data for the idle source’s callback.
@@ -3270,21 +3023,6 @@ export declare const internStaticString: (string?: string | null) => string;
  * @param string - a string
  */
 export declare const 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
- * @param userData - user data to pass to @func
- * @param notify - the function to call when the source is removed
- */
-export declare const ioAddWatchFull: (channel: IOChannel, priority: number, condition: IOCondition, func: (...args: unknown[]) => unknown, notify: () => void, userData?: number | null) => number;
 /**
  * Converts an `errno` error number to a #GIOChannelError.
  * @param en - an `errno` error number, e.g. `EINVAL`
@@ -3499,38 +3237,6 @@ export declare const logSetDebugEnabled: (enabled: boolean) => void;
  * @param fatalMask - the new fatal mask
  */
 export declare const 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.
- *
- * The `log_domain` parameter can be set to `NULL` or an empty string to use the default
- * application domain.
- * @param logDomain - the log domain
- * @param logLevels - the log levels to apply the log handler for.
- * @param logFunc - the log handler function
- * @param userData - data passed to the log handler
- * @param destroy - destroy notify for @user_data, or `NULL`
- */
-export declare const logSetHandlerFull: (logLevels: LogLevelFlags, logFunc: (...args: unknown[]) => unknown, destroy: () => void, logDomain?: string | null, userData?: number | null) => 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.
- * @param func - log writer function, which must not be `NULL`
- * @param userData - user data to pass to @func
- * @param userDataFree - function to free `user_data` once it’s
- */
-export declare const logSetWriterFunc: (func: (...args: unknown[]) => unknown, userDataFree: () => void, userData?: number | null) => void;
 /**
  * Log a message with structured data.
  *
@@ -4418,19 +4124,6 @@ export declare const prefixErrorLiteral: (prefix: string, err?: Ref<GError> | nu
  * @param src - error to move into the return location
  */
 export declare const propagateError: (src: GError, dest?: Ref<GError> | null) => void;
-/**
- * This is just like the standard C [`qsort()`](man:qsort(3)) function, but
- * the comparison routine accepts a user data argument
- * (like [`qsort_r()`](man:qsort_r(3))).
- *
- * Unlike `qsort()`, this is guaranteed to be a stable sort (since GLib 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
- * @param userData - data to pass to @compare_func
- */
-export declare const qsortWithData: (pbase: number, totalElems: number, size: number, compareFunc: (a: unknown, b: unknown) => number) => void;
 /**
  * Gets the #GQuark identifying the given (static) string. If the
  * string does not currently have an associated #GQuark, a new #GQuark
@@ -4804,16 +4497,6 @@ export declare const rename: (oldfilename: string, newfilename: string) => numbe
  * @param filename - a pathname in the GLib file name encoding
  */
 export declare const 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
- * @param userData - user data passed to @func
- */
-export declare const sequenceForeachRange: (begin: number, end: number, func: (...args: unknown[]) => unknown, userData?: number | null) => void;
 /**
  * Returns the data that `iter` points to.
  * @param iter - a #GSequenceIter
@@ -4885,36 +4568,6 @@ export declare const sequenceRemoveRange: (begin: number, end: number) => void;
  * @param data - new data for the item
  */
 export declare const sequenceSet: (iter: number, data?: number | 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
- * @param cmpData - user data passed to @cmp_func.
- */
-export declare const sequenceSortChanged: (iter: number, cmpFunc: (a: unknown, b: unknown) => number) => 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
- * @param cmpData - user data passed to @cmp_func
- */
-export declare const sequenceSortChangedIter: (iter: number, iterCmp: (...args: unknown[]) => unknown, cmpData?: number | null) => 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
@@ -5216,275 +4869,6 @@ export declare const sourceSetNameById: (tag: number, name: string) => void;
  * @param num - a #guint
  */
 export declare const spacedPrimesClosest: (num: number) => number;
-/**
- * Executes a child program asynchronously.
- *
- * See g_spawn_async_with_pipes_and_fds() for a full description; this function
- * simply calls the g_spawn_async_with_pipes() without any pipes, which in turn
- * calls g_spawn_async_with_pipes_and_fds().
- *
- * 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
- * @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
- * @param userData - user data for @child_setup
- * @param childPid - return location for child process reference, or %NULL
- */
-export declare const spawnAsync: (argv: string[], flags: SpawnFlags, workingDirectory?: string | null, envp?: string[] | null, childSetup?: (...args: unknown[]) => unknown | null, userData?: number | null, childPid?: Ref<number> | null) => boolean;
-/**
- * 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;
- * @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
- * @param userData - user data for @child_setup
- * @param childPid - return location for child process ID, or %NULL
- * @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`
- */
-export declare const spawnAsyncWithFds: (argv: string[], flags: SpawnFlags, stdinFd: number, stdoutFd: number, stderrFd: number, workingDirectory?: string | null, envp?: string[] | null, childSetup?: (...args: unknown[]) => unknown | null, userData?: number | null, childPid?: Ref<number> | null) => boolean;
-/**
- * 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
- * @param argv - child's argument
- * @param envp - child's environment, or %NULL to inherit parent's, in the GLib file
- * @param flags - flags from #GSpawnFlags
- * @param childSetup - function to run
- * @param userData - user data for @child_setup
- * @param childPid - return location for child process ID, or %NULL
- * @param standardInput - return location for file descriptor to write to child's stdin, or %NULL
- * @param standardOutput - return location for file descriptor to read child's stdout, or %NULL
- * @param standardError - return location for file descriptor to read child's stderr, or %NULL
- */
-export declare const spawnAsyncWithPipes: (argv: string[], flags: SpawnFlags, workingDirectory?: string | null, envp?: string[] | null, childSetup?: (...args: unknown[]) => unknown | null, userData?: number | null, childPid?: Ref<number> | null, standardInput?: Ref<number> | null, standardOutput?: Ref<number> | null, standardError?: Ref<number> | null) => boolean;
-/**
- * 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
- * @param argv - child's argument
- * @param envp - child's environment, or %NULL to inherit parent's, in the GLib file
- * @param flags - flags from #GSpawnFlags
- * @param childSetup - function to run
- * @param userData - user data for @child_setup
- * @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
- * @param targetFds - array of FDs to remap
- * @param nFds - number of FDs in `source_fds` and @target_fds
- * @param childPidOut - return location for child process ID, or %NULL
- * @param stdinPipeOut - return location for file descriptor to write to child's stdin, or %NULL
- * @param stdoutPipeOut - return location for file descriptor to read child's stdout, or %NULL
- * @param stderrPipeOut - return location for file descriptor to read child's stderr, or %NULL
- */
-export declare const spawnAsyncWithPipesAndFds: (argv: string[], flags: SpawnFlags, stdinFd: number, stdoutFd: number, stderrFd: number, nFds: number, workingDirectory?: string | null, envp?: string[] | null, childSetup?: (...args: unknown[]) => unknown | null, userData?: number | null, sourceFds?: number[] | null, targetFds?: number[] | null, childPidOut?: Ref<number> | null, stdinPipeOut?: Ref<number> | null, stdoutPipeOut?: Ref<number> | null, stderrPipeOut?: Ref<number> | null) => boolean;
 /**
  * An old name for g_spawn_check_wait_status(), deprecated because its
  * name is misleading.
@@ -5600,41 +4984,6 @@ export declare const spawnCommandLineAsync: (commandLine: string) => boolean;
 export declare const spawnCommandLineSync: (commandLine: string, standardOutput?: Ref<number[]> | null, standardError?: Ref<number[]> | null, waitStatus?: Ref<number> | null) => boolean;
 export declare const spawnErrorQuark: () => number;
 export declare const spawnExitErrorQuark: () => number;
-/**
- * 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
- * @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
- * @param userData - user data for @child_setup
- * @param standardOutput - return location for child output, or %NULL
- * @param standardError - return location for child error messages, or %NULL
- * @param waitStatus - return location for child wait status, as returned by waitpid(), or %NULL
- */
-export declare const spawnSync: (argv: string[], flags: SpawnFlags, workingDirectory?: string | null, envp?: string[] | null, childSetup?: (...args: unknown[]) => unknown | null, userData?: number | null, standardOutput?: Ref<number[]> | null, standardError?: Ref<number[]> | null, waitStatus?: Ref<number> | null) => boolean;
 /**
  * A wrapper for the POSIX stat() function. The stat() function
  * returns information about a file. On Windows the stat() function in
@@ -6201,56 +5550,6 @@ export declare const strvGetType: () => number;
  * @param strArray - an array of strings
  */
 export declare const strvLength: (strArray: string[]) => number;
-/**
- * Creates a new test case.
- *
- * This function is similar to [func@GLib.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 /-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 [func@GLib.test_trap_subprocess].
- *
- * No component of `testpath` may start with a dot (`.`) if the
- * [const@GLib.TEST_OPTION_ISOLATE_DIRS] option is being used;
- * and it is recommended to do so even if it isn’t.
- * @param testpath - a /-separated name for the test
- * @param testData - data for the @test_func
- * @param testFunc - the test function to invoke for this test
- */
-export declare const testAddDataFunc: (testpath: string, testFunc: (...args: unknown[]) => unknown, testData?: number | null) => void;
-/**
- * Creates a new test case.
- *
- * In contrast to [func@GLib.test_add_data_func], this function
- * is freeing `test_data` after the test run is complete.
- * @param testpath - a /-separated name for the test
- * @param testData - data for @test_func
- * @param testFunc - the test function to invoke for this test
- * @param dataFreeFunc - #GDestroyNotify for @test_data
- */
-export declare const testAddDataFuncFull: (testpath: string, testFunc: (...args: unknown[]) => unknown, dataFreeFunc: () => void, testData?: number | null) => void;
-/**
- * Creates a new test case.
- *
- * This function is similar to [func@GLib.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 /-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 [func@GLib.test_trap_subprocess].
- *
- * No component of `testpath` may start with a dot (`.`) if the
- * [const@GLib.TEST_OPTION_ISOLATE_DIRS] option is being used; and
- * it is recommended to do so even if it isn’t.
- * @param testpath - a /-separated name for the test
- * @param testFunc - the test function to invoke for this test
- */
-export declare const testAddFunc: (testpath: string, testFunc: (...args: unknown[]) => unknown) => void;
 export declare const testAssertExpectedMessagesInternal: (domain: string, file: string, line: number, func: string) => void;
 /**
  * Adds a message to test reports that associates a bug URI with a test case.
@@ -6843,89 +6142,6 @@ export declare const threadYield: () => void;
  * @param time_ - a #GTimeVal
  */
 export declare const timeValFromIso8601: (isoDate: string, time_: Ref<number>) => boolean;
-/**
- * Sets a function to be called at regular intervals, with the given
- * priority.
- *
- * The function is called repeatedly until it returns
- * [const@GLib.SOURCE_REMOVE], 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 main loop memory management for details
- * on how to handle the return value and memory management of @data.
- *
- * This internally creates a main loop source using
- * [func@GLib.timeout_source_new] and attaches it to the global
- * [struct@GLib.MainContext] using [method@GLib.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 [func@GLib.get_monotonic_time].
- * @param priority - the priority of the timeout source; typically this will be in
- * @param interval - the time between calls to the function, in milliseconds
- * @param _function - function to call
- * @param data - data to pass to @function
- * @param notify - function to call when the timeout is removed
- */
-export declare const timeoutAddFull: (priority: number, interval: number, _function: () => boolean, data?: number | null, notify?: () => void | null) => number;
-/**
- * Sets a function to be called at regular intervals, with @priority.
- *
- * The function is called repeatedly until it returns [const@GLib.SOURCE_REMOVE],
- * at which point the timeout is automatically destroyed and
- * the function will not be called again.
- *
- * Unlike [func@GLib.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 main loop 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
- * [func@GLib.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 [func@GLib.timeout_add_seconds] is preferred over
- * [func@GLib.timeout_add].
- *
- * This internally creates a main loop source using
- * [func@GLib.timeout_source_new_seconds] and attaches it to the main loop
- * context using [method@GLib.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 [func@GLib.get_monotonic_time].
- * @param priority - the priority of the timeout source; typically this will be in
- * @param interval - the time between calls to the function, in seconds
- * @param _function - function to call
- * @param data - data to pass to @function
- * @param notify - function to call when the timeout is removed
- */
-export declare const timeoutAddSecondsFull: (priority: number, interval: number, _function: () => boolean, data?: number | null, notify?: () => void | null) => number;
 /**
  * Creates a new timeout source.
  *
@@ -7390,21 +6606,6 @@ export declare const unicodeScriptFromIso15924: (iso15924: number) => UnicodeScr
  */
 export declare const unicodeScriptToIso15924: (script: UnicodeScript) => number;
 export declare const unixErrorQuark: () => number;
-/**
- * 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
- * @param userData - data to pass to @function
- * @param notify - function to call when the idle is removed, or %NULL
- */
-export declare const unixFdAddFull: (priority: number, fd: number, condition: IOCondition, _function: (...args: unknown[]) => unknown, notify: () => void, userData?: number | null) => number;
 /**
  * Creates a #GSource to watch for a particular I/O condition on a file
  * descriptor.
@@ -7464,17 +6665,6 @@ export declare const unixOpenPipe: (fds: number[], flags: number) => boolean;
  * @param nonblock - If %TRUE, set the descriptor to be non-blocking
  */
 export declare const 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
- * @param signum - Signal number
- * @param handler - Callback
- * @param userData - Data for @handler
- * @param notify - #GDestroyNotify for @handler
- */
-export declare const unixSignalAddFull: (priority: number, signum: number, handler: () => boolean, notify: () => void, userData?: number | null) => number;
 /**
  * Create a #GSource that will be dispatched upon delivery of the UNIX
  * signal @signum.  In GLib versions before 2.36, only `SIGHUP`, `SIGINT`,