/*
 * Licensed under the GNU Lesser General Public License Version 3
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the license, or
 * (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */

// generated automatically - do not change


module gi.glib;

import std.stdio;
import gi.glibtypes;
import gi.gobjecttypes;


__gshared extern(C)
{

	// glib.ArrayG

	GArray* g_array_append_vals (GArray* array, void* data, uint len);
	char* g_array_free (GArray* array, int freeSegment);
	uint g_array_get_element_size (GArray* array);
	GArray* g_array_insert_vals (GArray* array, uint index, void* data, uint len);
	GArray* g_array_new (int zeroTerminated, int clear, uint elementSize);
	GArray* g_array_prepend_vals (GArray* array, void* data, uint len);
	GArray* g_array_ref (GArray* array);
	GArray* g_array_remove_index (GArray* array, uint index);
	GArray* g_array_remove_index_fast (GArray* array, uint index);
	GArray* g_array_remove_range (GArray* array, uint index, uint length);
	void g_array_set_clear_func (GArray* array, GDestroyNotify clearFunc);
	GArray* g_array_set_size (GArray* array, uint length);
	GArray* g_array_sized_new (int zeroTerminated, int clear, uint elementSize, uint reservedSize);
	void g_array_sort (GArray* array, GCompareFunc compareFunc);
	void g_array_sort_with_data (GArray* array, GCompareDataFunc compareFunc, void* userData);
	void g_array_unref (GArray* array);

	// glib.AsyncQueue

	int g_async_queue_length (GAsyncQueue* queue);
	int g_async_queue_length_unlocked (GAsyncQueue* queue);
	void g_async_queue_lock (GAsyncQueue* queue);
	void* g_async_queue_pop (GAsyncQueue* queue);
	void* g_async_queue_pop_unlocked (GAsyncQueue* queue);
	void g_async_queue_push (GAsyncQueue* queue, void* data);
	void g_async_queue_push_front (GAsyncQueue* queue, void* item);
	void g_async_queue_push_front_unlocked (GAsyncQueue* queue, void* item);
	void g_async_queue_push_sorted (GAsyncQueue* queue, void* data, GCompareDataFunc func, void* userData);
	void g_async_queue_push_sorted_unlocked (GAsyncQueue* queue, void* data, GCompareDataFunc func, void* userData);
	void g_async_queue_push_unlocked (GAsyncQueue* queue, void* data);
	GAsyncQueue* g_async_queue_ref (GAsyncQueue* queue);
	void g_async_queue_ref_unlocked (GAsyncQueue* queue);
	int g_async_queue_remove (GAsyncQueue* queue, void* item);
	int g_async_queue_remove_unlocked (GAsyncQueue* queue, void* item);
	void g_async_queue_sort (GAsyncQueue* queue, GCompareDataFunc func, void* userData);
	void g_async_queue_sort_unlocked (GAsyncQueue* queue, GCompareDataFunc func, void* userData);
	void* g_async_queue_timed_pop (GAsyncQueue* queue, GTimeVal* endTime);
	void* g_async_queue_timed_pop_unlocked (GAsyncQueue* queue, GTimeVal* endTime);
	void* g_async_queue_timeout_pop (GAsyncQueue* queue, ulong timeout);
	void* g_async_queue_timeout_pop_unlocked (GAsyncQueue* queue, ulong timeout);
	void* g_async_queue_try_pop (GAsyncQueue* queue);
	void* g_async_queue_try_pop_unlocked (GAsyncQueue* queue);
	void g_async_queue_unlock (GAsyncQueue* queue);
	void g_async_queue_unref (GAsyncQueue* queue);
	void g_async_queue_unref_and_unlock (GAsyncQueue* queue);
	GAsyncQueue* g_async_queue_new ();
	GAsyncQueue* g_async_queue_new_full (GDestroyNotify itemFreeFunc);

	// glib.BookmarkFile

	void g_bookmark_file_add_application (GBookmarkFile* bookmark, const(char)* uri, const(char)* name, const(char)* exec);
	void g_bookmark_file_add_group (GBookmarkFile* bookmark, const(char)* uri, const(char)* group);
	void g_bookmark_file_free (GBookmarkFile* bookmark);
	uint g_bookmark_file_get_added (GBookmarkFile* bookmark, const(char)* uri, GError** err);
	int g_bookmark_file_get_app_info (GBookmarkFile* bookmark, const(char)* uri, const(char)* name, char** exec, uint* count, uint* stamp, GError** err);
	char** g_bookmark_file_get_applications (GBookmarkFile* bookmark, const(char)* uri, size_t* length, GError** err);
	char* g_bookmark_file_get_description (GBookmarkFile* bookmark, const(char)* uri, GError** err);
	char** g_bookmark_file_get_groups (GBookmarkFile* bookmark, const(char)* uri, size_t* length, GError** err);
	int g_bookmark_file_get_icon (GBookmarkFile* bookmark, const(char)* uri, char** href, char** mimeType, GError** err);
	int g_bookmark_file_get_is_private (GBookmarkFile* bookmark, const(char)* uri, GError** err);
	char* g_bookmark_file_get_mime_type (GBookmarkFile* bookmark, const(char)* uri, GError** err);
	uint g_bookmark_file_get_modified (GBookmarkFile* bookmark, const(char)* uri, GError** err);
	int g_bookmark_file_get_size (GBookmarkFile* bookmark);
	char* g_bookmark_file_get_title (GBookmarkFile* bookmark, const(char)* uri, GError** err);
	char** g_bookmark_file_get_uris (GBookmarkFile* bookmark, size_t* length);
	uint g_bookmark_file_get_visited (GBookmarkFile* bookmark, const(char)* uri, GError** err);
	int g_bookmark_file_has_application (GBookmarkFile* bookmark, const(char)* uri, const(char)* name, GError** err);
	int g_bookmark_file_has_group (GBookmarkFile* bookmark, const(char)* uri, const(char)* group, GError** err);
	int g_bookmark_file_has_item (GBookmarkFile* bookmark, const(char)* uri);
	int g_bookmark_file_load_from_data (GBookmarkFile* bookmark, const(char)* data, size_t length, GError** err);
	int g_bookmark_file_load_from_data_dirs (GBookmarkFile* bookmark, const(char)* file, char** fullPath, GError** err);
	int g_bookmark_file_load_from_file (GBookmarkFile* bookmark, const(char)* filename, GError** err);
	int g_bookmark_file_move_item (GBookmarkFile* bookmark, const(char)* oldUri, const(char)* newUri, GError** err);
	int g_bookmark_file_remove_application (GBookmarkFile* bookmark, const(char)* uri, const(char)* name, GError** err);
	int g_bookmark_file_remove_group (GBookmarkFile* bookmark, const(char)* uri, const(char)* group, GError** err);
	int g_bookmark_file_remove_item (GBookmarkFile* bookmark, const(char)* uri, GError** err);
	void g_bookmark_file_set_added (GBookmarkFile* bookmark, const(char)* uri, uint added);
	int g_bookmark_file_set_app_info (GBookmarkFile* bookmark, const(char)* uri, const(char)* name, const(char)* exec, int count, uint stamp, GError** err);
	void g_bookmark_file_set_description (GBookmarkFile* bookmark, const(char)* uri, const(char)* description);
	void g_bookmark_file_set_groups (GBookmarkFile* bookmark, const(char)* uri, char** groups, size_t length);
	void g_bookmark_file_set_icon (GBookmarkFile* bookmark, const(char)* uri, const(char)* href, const(char)* mimeType);
	void g_bookmark_file_set_is_private (GBookmarkFile* bookmark, const(char)* uri, int isPrivate);
	void g_bookmark_file_set_mime_type (GBookmarkFile* bookmark, const(char)* uri, const(char)* mimeType);
	void g_bookmark_file_set_modified (GBookmarkFile* bookmark, const(char)* uri, uint modified);
	void g_bookmark_file_set_title (GBookmarkFile* bookmark, const(char)* uri, const(char)* title);
	void g_bookmark_file_set_visited (GBookmarkFile* bookmark, const(char)* uri, uint visited);
	char* g_bookmark_file_to_data (GBookmarkFile* bookmark, size_t* length, GError** err);
	int g_bookmark_file_to_file (GBookmarkFile* bookmark, const(char)* filename, GError** err);
	GQuark g_bookmark_file_error_quark ();
	GBookmarkFile* g_bookmark_file_new ();

	// glib.ByteArray

	GByteArray* g_byte_array_append (GByteArray* array, ubyte* data, uint len);
	ubyte* g_byte_array_free (GByteArray* array, int freeSegment);
	GBytes* g_byte_array_free_to_bytes (GByteArray* array);
	GByteArray* g_byte_array_new ();
	GByteArray* g_byte_array_new_take (ubyte* data, size_t len);
	GByteArray* g_byte_array_prepend (GByteArray* array, ubyte* data, uint len);
	GByteArray* g_byte_array_ref (GByteArray* array);
	GByteArray* g_byte_array_remove_index (GByteArray* array, uint index);
	GByteArray* g_byte_array_remove_index_fast (GByteArray* array, uint index);
	GByteArray* g_byte_array_remove_range (GByteArray* array, uint index, uint length);
	GByteArray* g_byte_array_set_size (GByteArray* array, uint length);
	GByteArray* g_byte_array_sized_new (uint reservedSize);
	void g_byte_array_sort (GByteArray* array, GCompareFunc compareFunc);
	void g_byte_array_sort_with_data (GByteArray* array, GCompareDataFunc compareFunc, void* userData);
	void g_byte_array_unref (GByteArray* array);

	// glib.Bytes

	GBytes* g_bytes_new (void* data, size_t size);
	GBytes* g_bytes_new_static (void* data, size_t size);
	GBytes* g_bytes_new_take (void* data, size_t size);
	GBytes* g_bytes_new_with_free_func (void* data, size_t size, GDestroyNotify freeFunc, void* userData);
	int g_bytes_compare (void* bytes1, void* bytes2);
	int g_bytes_equal (void* bytes1, void* bytes2);
	void* g_bytes_get_data (GBytes* bytes, size_t* size);
	size_t g_bytes_get_size (GBytes* bytes);
	uint g_bytes_hash (void* bytes);
	GBytes* g_bytes_new_from_bytes (GBytes* bytes, size_t offset, size_t length);
	GBytes* g_bytes_ref (GBytes* bytes);
	void g_bytes_unref (GBytes* bytes);
	GByteArray* g_bytes_unref_to_array (GBytes* bytes);
	void* g_bytes_unref_to_data (GBytes* bytes, size_t* size);

	// glib.Checksum

	GChecksum* g_checksum_new (GChecksumType checksumType);
	GChecksum* g_checksum_copy (GChecksum* checksum);
	void g_checksum_free (GChecksum* checksum);
	void g_checksum_get_digest (GChecksum* checksum, ubyte* buffer, size_t* digestLen);
	const(char)* g_checksum_get_string (GChecksum* checksum);
	void g_checksum_reset (GChecksum* checksum);
	void g_checksum_update (GChecksum* checksum, char* data, ptrdiff_t length);
	ptrdiff_t g_checksum_type_get_length (GChecksumType checksumType);
	char* g_compute_checksum_for_bytes (GChecksumType checksumType, GBytes* data);
	char* g_compute_checksum_for_data (GChecksumType checksumType, char* data, size_t length);
	char* g_compute_checksum_for_string (GChecksumType checksumType, const(char)* str, ptrdiff_t length);

	// glib.Cond

	void g_cond_broadcast (GCond* cond);
	void g_cond_clear (GCond* cond);
	void g_cond_init (GCond* cond);
	void g_cond_signal (GCond* cond);
	void g_cond_wait (GCond* cond, GMutex* mutex);
	int g_cond_wait_until (GCond* cond, GMutex* mutex, long endTime);

	// glib.Date

	GDate* g_date_new ();
	GDate* g_date_new_dmy (GDateDay day, GDateMonth month, GDateYear year);
	GDate* g_date_new_julian (uint julianDay);
	void g_date_add_days (GDate* date, uint nDays);
	void g_date_add_months (GDate* date, uint nMonths);
	void g_date_add_years (GDate* date, uint nYears);
	void g_date_clamp (GDate* date, GDate* minDate, GDate* maxDate);
	void g_date_clear (GDate* date, uint nDates);
	int g_date_compare (GDate* lhs, GDate* rhs);
	int g_date_days_between (GDate* date1, GDate* date2);
	void g_date_free (GDate* date);
	GDateDay g_date_get_day (GDate* date);
	uint g_date_get_day_of_year (GDate* date);
	uint g_date_get_iso8601_week_of_year (GDate* date);
	uint g_date_get_julian (GDate* date);
	uint g_date_get_monday_week_of_year (GDate* date);
	GDateMonth g_date_get_month (GDate* date);
	uint g_date_get_sunday_week_of_year (GDate* date);
	GDateWeekday g_date_get_weekday (GDate* date);
	GDateYear g_date_get_year (GDate* date);
	int g_date_is_first_of_month (GDate* date);
	int g_date_is_last_of_month (GDate* date);
	void g_date_order (GDate* date1, GDate* date2);
	void g_date_set_day (GDate* date, GDateDay day);
	void g_date_set_dmy (GDate* date, GDateDay day, GDateMonth month, GDateYear y);
	void g_date_set_julian (GDate* date, uint julianDate);
	void g_date_set_month (GDate* date, GDateMonth month);
	void g_date_set_parse (GDate* date, const(char)* str);
	void g_date_set_time (GDate* date, GTime time);
	void g_date_set_time_t (GDate* date, uint timet);
	void g_date_set_time_val (GDate* date, GTimeVal* timeval);
	void g_date_set_year (GDate* date, GDateYear year);
	void g_date_subtract_days (GDate* date, uint nDays);
	void g_date_subtract_months (GDate* date, uint nMonths);
	void g_date_subtract_years (GDate* date, uint nYears);
	void g_date_to_struct_tm (GDate* date, void* tm);
	int g_date_valid (GDate* date);
	ubyte g_date_get_days_in_month (GDateMonth month, GDateYear year);
	ubyte g_date_get_monday_weeks_in_year (GDateYear year);
	ubyte g_date_get_sunday_weeks_in_year (GDateYear year);
	int g_date_is_leap_year (GDateYear year);
	size_t g_date_strftime (char* s, size_t slen, const(char)* format, GDate* date);
	int g_date_valid_day (GDateDay day);
	int g_date_valid_dmy (GDateDay day, GDateMonth month, GDateYear year);
	int g_date_valid_julian (uint julianDate);
	int g_date_valid_month (GDateMonth month);
	int g_date_valid_weekday (GDateWeekday weekday);
	int g_date_valid_year (GDateYear year);

	// glib.DateTime

	GDateTime* g_date_time_new (GTimeZone* tz, int year, int month, int day, int hour, int minute, double seconds);
	GDateTime* g_date_time_new_from_timeval_local (GTimeVal* tv);
	GDateTime* g_date_time_new_from_timeval_utc (GTimeVal* tv);
	GDateTime* g_date_time_new_from_unix_local (long t);
	GDateTime* g_date_time_new_from_unix_utc (long t);
	GDateTime* g_date_time_new_local (int year, int month, int day, int hour, int minute, double seconds);
	GDateTime* g_date_time_new_now (GTimeZone* tz);
	GDateTime* g_date_time_new_now_local ();
	GDateTime* g_date_time_new_now_utc ();
	GDateTime* g_date_time_new_utc (int year, int month, int day, int hour, int minute, double seconds);
	GDateTime* g_date_time_add (GDateTime* datetime, GTimeSpan timespan);
	GDateTime* g_date_time_add_days (GDateTime* datetime, int days);
	GDateTime* g_date_time_add_full (GDateTime* datetime, int years, int months, int days, int hours, int minutes, double seconds);
	GDateTime* g_date_time_add_hours (GDateTime* datetime, int hours);
	GDateTime* g_date_time_add_minutes (GDateTime* datetime, int minutes);
	GDateTime* g_date_time_add_months (GDateTime* datetime, int months);
	GDateTime* g_date_time_add_seconds (GDateTime* datetime, double seconds);
	GDateTime* g_date_time_add_weeks (GDateTime* datetime, int weeks);
	GDateTime* g_date_time_add_years (GDateTime* datetime, int years);
	GTimeSpan g_date_time_difference (GDateTime* end, GDateTime* begin);
	char* g_date_time_format (GDateTime* datetime, const(char)* format);
	int g_date_time_get_day_of_month (GDateTime* datetime);
	int g_date_time_get_day_of_week (GDateTime* datetime);
	int g_date_time_get_day_of_year (GDateTime* datetime);
	int g_date_time_get_hour (GDateTime* datetime);
	int g_date_time_get_microsecond (GDateTime* datetime);
	int g_date_time_get_minute (GDateTime* datetime);
	int g_date_time_get_month (GDateTime* datetime);
	int g_date_time_get_second (GDateTime* datetime);
	double g_date_time_get_seconds (GDateTime* datetime);
	const(char)* g_date_time_get_timezone_abbreviation (GDateTime* datetime);
	GTimeSpan g_date_time_get_utc_offset (GDateTime* datetime);
	int g_date_time_get_week_numbering_year (GDateTime* datetime);
	int g_date_time_get_week_of_year (GDateTime* datetime);
	int g_date_time_get_year (GDateTime* datetime);
	void g_date_time_get_ymd (GDateTime* datetime, int* year, int* month, int* day);
	int g_date_time_is_daylight_savings (GDateTime* datetime);
	GDateTime* g_date_time_ref (GDateTime* datetime);
	GDateTime* g_date_time_to_local (GDateTime* datetime);
	int g_date_time_to_timeval (GDateTime* datetime, GTimeVal* tv);
	GDateTime* g_date_time_to_timezone (GDateTime* datetime, GTimeZone* tz);
	long g_date_time_to_unix (GDateTime* datetime);
	GDateTime* g_date_time_to_utc (GDateTime* datetime);
	void g_date_time_unref (GDateTime* datetime);
	int g_date_time_compare (void* dt1, void* dt2);
	int g_date_time_equal (void* dt1, void* dt2);
	uint g_date_time_hash (void* datetime);

	// glib.Directory

	void g_dir_close (GDir* dir);
	const(char)* g_dir_read_name (GDir* dir);
	void g_dir_rewind (GDir* dir);
	char* g_dir_make_tmp (char* tmpl, GError** err);
	GDir* g_dir_open (const(char)* path, uint flags, GError** err);

	// glib.ErrorG

	GError* g_error_new (GQuark domain, int code, const(char)* format, ... );
	GError* g_error_new_literal (GQuark domain, int code, const(char)* message);
	GError* g_error_new_valist (GQuark domain, int code, const(char)* format, void* args);
	GError* g_error_copy (GError* error);
	void g_error_free (GError* error);
	int g_error_matches (GError* error, GQuark domain, int code);
	void g_propagate_error (GError** dest, GError* src);
	void g_set_error_literal (GError** err, GQuark domain, int code, const(char)* message);
	void g_prefix_error (GError** err, const(char)* format, ... );
	void g_propagate_prefixed_error (GError** dest, GError* src, const(char)* format, ... );
	void g_set_error (GError** err, GQuark domain, int code, const(char)* format, ... );

	// glib.HashTable

	int g_hash_table_add (GHashTable* hashTable, void* key);
	int g_hash_table_contains (GHashTable* hashTable, void* key);
	void g_hash_table_destroy (GHashTable* hashTable);
	void* g_hash_table_find (GHashTable* hashTable, GHRFunc predicate, void* userData);
	void g_hash_table_foreach (GHashTable* hashTable, GHFunc func, void* userData);
	uint g_hash_table_foreach_remove (GHashTable* hashTable, GHRFunc func, void* userData);
	uint g_hash_table_foreach_steal (GHashTable* hashTable, GHRFunc func, void* userData);
	GList* g_hash_table_get_keys (GHashTable* hashTable);
	void** g_hash_table_get_keys_as_array (GHashTable* hashTable, uint* length);
	GList* g_hash_table_get_values (GHashTable* hashTable);
	int g_hash_table_insert (GHashTable* hashTable, void* key, void* value);
	void* g_hash_table_lookup (GHashTable* hashTable, void* key);
	int g_hash_table_lookup_extended (GHashTable* hashTable, void* lookupKey, void** origKey, void** value);
	GHashTable* g_hash_table_new (GHashFunc hashFunc, GEqualFunc keyEqualFunc);
	GHashTable* g_hash_table_new_full (GHashFunc hashFunc, GEqualFunc keyEqualFunc, GDestroyNotify keyDestroyFunc, GDestroyNotify valueDestroyFunc);
	GHashTable* g_hash_table_ref (GHashTable* hashTable);
	int g_hash_table_remove (GHashTable* hashTable, void* key);
	void g_hash_table_remove_all (GHashTable* hashTable);
	int g_hash_table_replace (GHashTable* hashTable, void* key, void* value);
	uint g_hash_table_size (GHashTable* hashTable);
	int g_hash_table_steal (GHashTable* hashTable, void* key);
	void g_hash_table_steal_all (GHashTable* hashTable);
	void g_hash_table_unref (GHashTable* hashTable);
	int g_direct_equal (void* v1, void* v2);
	uint g_direct_hash (void* v);
	int g_double_equal (void* v1, void* v2);
	uint g_double_hash (void* v);
	int g_int64_equal (void* v1, void* v2);
	uint g_int64_hash (void* v);
	int g_int_equal (void* v1, void* v2);
	uint g_int_hash (void* v);
	int g_str_equal (void* v1, void* v2);
	uint g_str_hash (void* v);

	// glib.HashTableIter

	GHashTable* g_hash_table_iter_get_hash_table (GHashTableIter* iter);
	void g_hash_table_iter_init (GHashTableIter* iter, GHashTable* hashTable);
	int g_hash_table_iter_next (GHashTableIter* iter, void** key, void** value);
	void g_hash_table_iter_remove (GHashTableIter* iter);
	void g_hash_table_iter_replace (GHashTableIter* iter, void* value);
	void g_hash_table_iter_steal (GHashTableIter* iter);

	// glib.Hmac

	GHmac* g_hmac_copy (GHmac* hmac);
	void g_hmac_get_digest (GHmac* hmac, ubyte* buffer, size_t* digestLen);
	const(char)* g_hmac_get_string (GHmac* hmac);
	GHmac* g_hmac_ref (GHmac* hmac);
	void g_hmac_unref (GHmac* hmac);
	void g_hmac_update (GHmac* hmac, char* data, ptrdiff_t length);
	GHmac* g_hmac_new (GChecksumType digestType, char* key, size_t keyLen);
	char* g_compute_hmac_for_data (GChecksumType digestType, char* key, size_t keyLen, char* data, size_t length);
	char* g_compute_hmac_for_string (GChecksumType digestType, char* key, size_t keyLen, const(char)* str, ptrdiff_t length);

	// glib.Hook

	int g_hook_compare_ids (GHook* newHook, GHook* sibling);
	GHook* g_hook_alloc (GHookList* hookList);
	int g_hook_destroy (GHookList* hookList, gulong hookId);
	void g_hook_destroy_link (GHookList* hookList, GHook* hook);
	GHook* g_hook_find (GHookList* hookList, int needValids, GHookFindFunc func, void* data);
	GHook* g_hook_find_data (GHookList* hookList, int needValids, void* data);
	GHook* g_hook_find_func (GHookList* hookList, int needValids, void* func);
	GHook* g_hook_find_func_data (GHookList* hookList, int needValids, void* func, void* data);
	GHook* g_hook_first_valid (GHookList* hookList, int mayBeInCall);
	void g_hook_free (GHookList* hookList, GHook* hook);
	GHook* g_hook_get (GHookList* hookList, gulong hookId);
	void g_hook_insert_before (GHookList* hookList, GHook* sibling, GHook* hook);
	void g_hook_insert_sorted (GHookList* hookList, GHook* hook, GHookCompareFunc func);
	GHook* g_hook_next_valid (GHookList* hookList, GHook* hook, int mayBeInCall);
	void g_hook_prepend (GHookList* hookList, GHook* hook);
	GHook* g_hook_ref (GHookList* hookList, GHook* hook);
	void g_hook_unref (GHookList* hookList, GHook* hook);

	// glib.HookList

	void g_hook_list_clear (GHookList* hookList);
	void g_hook_list_init (GHookList* hookList, uint hookSize);
	void g_hook_list_invoke (GHookList* hookList, int mayRecurse);
	void g_hook_list_invoke_check (GHookList* hookList, int mayRecurse);
	void g_hook_list_marshal (GHookList* hookList, int mayRecurse, GHookMarshaller marshaller, void* marshalData);
	void g_hook_list_marshal_check (GHookList* hookList, int mayRecurse, GHookCheckMarshaller marshaller, void* marshalData);

	// glib.IConv

	size_t g_iconv (GIConv converter, char** inbuf, size_t* inbytesLeft, char** outbuf, size_t* outbytesLeft);
	int g_iconv_close (GIConv converter);
	GIConv g_iconv_open (const(char)* toCodeset, const(char)* fromCodeset);

	// glib.IOChannel

	GIOChannel* g_io_channel_new_file (const(char)* filename, const(char)* mode, GError** err);
	GIOChannel* g_io_channel_unix_new (int fd);
	void g_io_channel_close (GIOChannel* channel);
	GIOStatus g_io_channel_flush (GIOChannel* channel, GError** err);
	GIOCondition g_io_channel_get_buffer_condition (GIOChannel* channel);
	size_t g_io_channel_get_buffer_size (GIOChannel* channel);
	int g_io_channel_get_buffered (GIOChannel* channel);
	int g_io_channel_get_close_on_unref (GIOChannel* channel);
	const(char)* g_io_channel_get_encoding (GIOChannel* channel);
	GIOFlags g_io_channel_get_flags (GIOChannel* channel);
	const(char)* g_io_channel_get_line_term (GIOChannel* channel, int* length);
	void g_io_channel_init (GIOChannel* channel);
	GIOError g_io_channel_read (GIOChannel* channel, char* buf, size_t count, size_t* bytesRead);
	GIOStatus g_io_channel_read_chars (GIOChannel* channel, char* buf, size_t count, size_t* bytesRead, GError** err);
	GIOStatus g_io_channel_read_line (GIOChannel* channel, char** strReturn, size_t* length, size_t* terminatorPos, GError** err);
	GIOStatus g_io_channel_read_line_string (GIOChannel* channel, GString* buffer, size_t* terminatorPos, GError** err);
	GIOStatus g_io_channel_read_to_end (GIOChannel* channel, char** strReturn, size_t* length, GError** err);
	GIOStatus g_io_channel_read_unichar (GIOChannel* channel, dchar* thechar, GError** err);
	GIOChannel* g_io_channel_ref (GIOChannel* channel);
	GIOError g_io_channel_seek (GIOChannel* channel, long offset, GSeekType type);
	GIOStatus g_io_channel_seek_position (GIOChannel* channel, long offset, GSeekType type, GError** err);
	void g_io_channel_set_buffer_size (GIOChannel* channel, size_t size);
	void g_io_channel_set_buffered (GIOChannel* channel, int buffered);
	void g_io_channel_set_close_on_unref (GIOChannel* channel, int doClose);
	GIOStatus g_io_channel_set_encoding (GIOChannel* channel, const(char)* encoding, GError** err);
	GIOStatus g_io_channel_set_flags (GIOChannel* channel, GIOFlags flags, GError** err);
	void g_io_channel_set_line_term (GIOChannel* channel, const(char)* lineTerm, int length);
	GIOStatus g_io_channel_shutdown (GIOChannel* channel, int flush, GError** err);
	int g_io_channel_unix_get_fd (GIOChannel* channel);
	void g_io_channel_unref (GIOChannel* channel);
	GIOError g_io_channel_write (GIOChannel* channel, const(char)* buf, size_t count, size_t* bytesWritten);
	GIOStatus g_io_channel_write_chars (GIOChannel* channel, char* buf, ptrdiff_t count, size_t* bytesWritten, GError** err);
	GIOStatus g_io_channel_write_unichar (GIOChannel* channel, dchar thechar, GError** err);
	GIOChannelError g_io_channel_error_from_errno (int en);
	GQuark g_io_channel_error_quark ();
	uint g_io_add_watch (GIOChannel* channel, GIOCondition condition, GIOFunc func, void* userData);
	uint g_io_add_watch_full (GIOChannel* channel, int priority, GIOCondition condition, GIOFunc func, void* userData, GDestroyNotify notify);
	GSource* g_io_create_watch (GIOChannel* channel, GIOCondition condition);

	// glib.KeyFile

	GKeyFile* g_key_file_new ();
	void g_key_file_free (GKeyFile* keyFile);
	int g_key_file_get_boolean (GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
	int* g_key_file_get_boolean_list (GKeyFile* keyFile, const(char)* groupName, const(char)* key, size_t* length, GError** err);
	char* g_key_file_get_comment (GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
	double g_key_file_get_double (GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
	double* g_key_file_get_double_list (GKeyFile* keyFile, const(char)* groupName, const(char)* key, size_t* length, GError** err);
	char** g_key_file_get_groups (GKeyFile* keyFile, size_t* length);
	long g_key_file_get_int64 (GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
	int g_key_file_get_integer (GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
	int* g_key_file_get_integer_list (GKeyFile* keyFile, const(char)* groupName, const(char)* key, size_t* length, GError** err);
	char** g_key_file_get_keys (GKeyFile* keyFile, const(char)* groupName, size_t* length, GError** err);
	char* g_key_file_get_locale_string (GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* locale, GError** err);
	char** g_key_file_get_locale_string_list (GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* locale, size_t* length, GError** err);
	char* g_key_file_get_start_group (GKeyFile* keyFile);
	char* g_key_file_get_string (GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
	char** g_key_file_get_string_list (GKeyFile* keyFile, const(char)* groupName, const(char)* key, size_t* length, GError** err);
	ulong g_key_file_get_uint64 (GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
	char* g_key_file_get_value (GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
	int g_key_file_has_group (GKeyFile* keyFile, const(char)* groupName);
	int g_key_file_has_key (GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
	int g_key_file_load_from_data (GKeyFile* keyFile, const(char)* data, size_t length, GKeyFileFlags flags, GError** err);
	int g_key_file_load_from_data_dirs (GKeyFile* keyFile, char* file, char** fullPath, GKeyFileFlags flags, GError** err);
	int g_key_file_load_from_dirs (GKeyFile* keyFile, char* file, char** searchDirs, char** fullPath, GKeyFileFlags flags, GError** err);
	int g_key_file_load_from_file (GKeyFile* keyFile, char* file, GKeyFileFlags flags, GError** err);
	GKeyFile* g_key_file_ref (GKeyFile* keyFile);
	int g_key_file_remove_comment (GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
	int g_key_file_remove_group (GKeyFile* keyFile, const(char)* groupName, GError** err);
	int g_key_file_remove_key (GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
	int g_key_file_save_to_file (GKeyFile* keyFile, const(char)* filename, GError** err);
	void g_key_file_set_boolean (GKeyFile* keyFile, const(char)* groupName, const(char)* key, int value);
	void g_key_file_set_boolean_list (GKeyFile* keyFile, const(char)* groupName, const(char)* key, int* list, size_t length);
	int g_key_file_set_comment (GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* comment, GError** err);
	void g_key_file_set_double (GKeyFile* keyFile, const(char)* groupName, const(char)* key, double value);
	void g_key_file_set_double_list (GKeyFile* keyFile, const(char)* groupName, const(char)* key, double* list, size_t length);
	void g_key_file_set_int64 (GKeyFile* keyFile, const(char)* groupName, const(char)* key, long value);
	void g_key_file_set_integer (GKeyFile* keyFile, const(char)* groupName, const(char)* key, int value);
	void g_key_file_set_integer_list (GKeyFile* keyFile, const(char)* groupName, const(char)* key, int* list, size_t length);
	void g_key_file_set_list_separator (GKeyFile* keyFile, char separator);
	void g_key_file_set_locale_string (GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* locale, const(char)* str);
	void g_key_file_set_locale_string_list (GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* locale, char* list, size_t length);
	void g_key_file_set_string (GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* str);
	void g_key_file_set_string_list (GKeyFile* keyFile, const(char)* groupName, const(char)* key, char** list, size_t length);
	void g_key_file_set_uint64 (GKeyFile* keyFile, const(char)* groupName, const(char)* key, ulong value);
	void g_key_file_set_value (GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* value);
	char* g_key_file_to_data (GKeyFile* keyFile, size_t* length, GError** err);
	void g_key_file_unref (GKeyFile* keyFile);
	GQuark g_key_file_error_quark ();

	// glib.ListG

	GList* g_list_alloc ();
	GList* g_list_append (GList* list, void* data);
	GList* g_list_concat (GList* list1, GList* list2);
	GList* g_list_copy (GList* list);
	GList* g_list_copy_deep (GList* list, GCopyFunc func, void* userData);
	GList* g_list_delete_link (GList* list, GList* link);
	GList* g_list_find (GList* list, void* data);
	GList* g_list_find_custom (GList* list, void* data, GCompareFunc func);
	GList* g_list_first (GList* list);
	void g_list_foreach (GList* list, GFunc func, void* userData);
	void g_list_free (GList* list);
	void g_list_free_1 (GList* list);
	void g_list_free_full (GList* list, GDestroyNotify freeFunc);
	int g_list_index (GList* list, void* data);
	GList* g_list_insert (GList* list, void* data, int position);
	GList* g_list_insert_before (GList* list, GList* sibling, void* data);
	GList* g_list_insert_sorted (GList* list, void* data, GCompareFunc func);
	GList* g_list_insert_sorted_with_data (GList* list, void* data, GCompareDataFunc func, void* userData);
	GList* g_list_last (GList* list);
	uint g_list_length (GList* list);
	GList* g_list_nth (GList* list, uint n);
	void* g_list_nth_data (GList* list, uint n);
	GList* g_list_nth_prev (GList* list, uint n);
	int g_list_position (GList* list, GList* llink);
	GList* g_list_prepend (GList* list, void* data);
	GList* g_list_remove (GList* list, void* data);
	GList* g_list_remove_all (GList* list, void* data);
	GList* g_list_remove_link (GList* list, GList* llink);
	GList* g_list_reverse (GList* list);
	GList* g_list_sort (GList* list, GCompareFunc compareFunc);
	GList* g_list_sort_with_data (GList* list, GCompareDataFunc compareFunc, void* userData);

	// glib.MainContext

	GMainContext* g_main_context_new ();
	int g_main_context_acquire (GMainContext* context);
	void g_main_context_add_poll (GMainContext* context, GPollFD* fd, int priority);
	int g_main_context_check (GMainContext* context, int maxPriority, GPollFD* fds, int nFds);
	void g_main_context_dispatch (GMainContext* context);
	GSource* g_main_context_find_source_by_funcs_user_data (GMainContext* context, GSourceFuncs* funcs, void* userData);
	GSource* g_main_context_find_source_by_id (GMainContext* context, uint sourceId);
	GSource* g_main_context_find_source_by_user_data (GMainContext* context, void* userData);
	GPollFunc g_main_context_get_poll_func (GMainContext* context);
	void g_main_context_invoke (GMainContext* context, GSourceFunc funct, void* data);
	void g_main_context_invoke_full (GMainContext* context, int priority, GSourceFunc funct, void* data, GDestroyNotify notify);
	int g_main_context_is_owner (GMainContext* context);
	int g_main_context_iteration (GMainContext* context, int mayBlock);
	int g_main_context_pending (GMainContext* context);
	void g_main_context_pop_thread_default (GMainContext* context);
	int g_main_context_prepare (GMainContext* context, int* priority);
	void g_main_context_push_thread_default (GMainContext* context);
	int g_main_context_query (GMainContext* context, int maxPriority, int* timeout, GPollFD* fds, int nFds);
	GMainContext* g_main_context_ref (GMainContext* context);
	void g_main_context_release (GMainContext* context);
	void g_main_context_remove_poll (GMainContext* context, GPollFD* fd);
	void g_main_context_set_poll_func (GMainContext* context, GPollFunc func);
	void g_main_context_unref (GMainContext* context);
	int g_main_context_wait (GMainContext* context, GCond* cond, GMutex* mutex);
	void g_main_context_wakeup (GMainContext* context);
	GMainContext* g_main_context_default ();
	GMainContext* g_main_context_get_thread_default ();
	GMainContext* g_main_context_ref_thread_default ();

	// glib.MainLoop

	GMainLoop* g_main_loop_new (GMainContext* context, int isRunning);
	GMainContext* g_main_loop_get_context (GMainLoop* loop);
	int g_main_loop_is_running (GMainLoop* loop);
	void g_main_loop_quit (GMainLoop* loop);
	GMainLoop* g_main_loop_ref (GMainLoop* loop);
	void g_main_loop_run (GMainLoop* loop);
	void g_main_loop_unref (GMainLoop* loop);
	GSource* g_main_current_source ();
	int g_main_depth ();
	int g_poll (GPollFD* fds, uint nfds, int timeout);

	// glib.MappedFile

	GMappedFile* g_mapped_file_new (const(char)* filename, int writable, GError** err);
	GMappedFile* g_mapped_file_new_from_fd (int fd, int writable, GError** err);
	void g_mapped_file_free (GMappedFile* file);
	GBytes* g_mapped_file_get_bytes (GMappedFile* file);
	char* g_mapped_file_get_contents (GMappedFile* file);
	size_t g_mapped_file_get_length (GMappedFile* file);
	GMappedFile* g_mapped_file_ref (GMappedFile* file);
	void g_mapped_file_unref (GMappedFile* file);

	// glib.SimpleXML

	GMarkupParseContext* g_markup_parse_context_new (GMarkupParser* parser, GMarkupParseFlags flags, void* userData, GDestroyNotify userDataDnotify);
	int g_markup_parse_context_end_parse (GMarkupParseContext* context, GError** err);
	void g_markup_parse_context_free (GMarkupParseContext* context);
	const(char)* g_markup_parse_context_get_element (GMarkupParseContext* context);
	GSList* g_markup_parse_context_get_element_stack (GMarkupParseContext* context);
	void g_markup_parse_context_get_position (GMarkupParseContext* context, int* lineNumber, int* charNumber);
	void* g_markup_parse_context_get_user_data (GMarkupParseContext* context);
	int g_markup_parse_context_parse (GMarkupParseContext* context, const(char)* text, ptrdiff_t textLen, GError** err);
	void* g_markup_parse_context_pop (GMarkupParseContext* context);
	void g_markup_parse_context_push (GMarkupParseContext* context, GMarkupParser* parser, void* userData);
	GMarkupParseContext* g_markup_parse_context_ref (GMarkupParseContext* context);
	void g_markup_parse_context_unref (GMarkupParseContext* context);
	int g_markup_collect_attributes (const(char)* elementName, char** attributeNames, char** attributeValues, GError** error, GMarkupCollectType firstType, const(char)* firstAttr, ... );
	GQuark g_markup_error_quark ();
	char* g_markup_escape_text (const(char)* text, ptrdiff_t length);
	char* g_markup_printf_escaped (const(char)* format, ... );
	char* g_markup_vprintf_escaped (const(char)* format, void* args);

	// glib.MatchInfo

	char* g_match_info_expand_references (GMatchInfo* matchInfo, const(char)* stringToExpand, GError** err);
	char* g_match_info_fetch (GMatchInfo* matchInfo, int matchNum);
	char** g_match_info_fetch_all (GMatchInfo* matchInfo);
	char* g_match_info_fetch_named (GMatchInfo* matchInfo, const(char)* name);
	int g_match_info_fetch_named_pos (GMatchInfo* matchInfo, const(char)* name, int* startPos, int* endPos);
	int g_match_info_fetch_pos (GMatchInfo* matchInfo, int matchNum, int* startPos, int* endPos);
	void g_match_info_free (GMatchInfo* matchInfo);
	int g_match_info_get_match_count (GMatchInfo* matchInfo);
	GRegex* g_match_info_get_regex (GMatchInfo* matchInfo);
	const(char)* g_match_info_get_string (GMatchInfo* matchInfo);
	int g_match_info_is_partial_match (GMatchInfo* matchInfo);
	int g_match_info_matches (GMatchInfo* matchInfo);
	int g_match_info_next (GMatchInfo* matchInfo, GError** err);
	GMatchInfo* g_match_info_ref (GMatchInfo* matchInfo);
	void g_match_info_unref (GMatchInfo* matchInfo);

	// glib.Mutex

	void g_mutex_clear (GMutex* mutex);
	void g_mutex_init (GMutex* mutex);
	void g_mutex_lock (GMutex* mutex);
	int g_mutex_trylock (GMutex* mutex);
	void g_mutex_unlock (GMutex* mutex);

	// glib.Node

	int g_node_child_index (GNode* node, void* data);
	int g_node_child_position (GNode* node, GNode* child);
	void g_node_children_foreach (GNode* node, GTraverseFlags flags, GNodeForeachFunc func, void* data);
	GNode* g_node_copy (GNode* node);
	GNode* g_node_copy_deep (GNode* node, GCopyFunc copyFunc, void* data);
	uint g_node_depth (GNode* node);
	void g_node_destroy (GNode* root);
	GNode* g_node_find (GNode* root, GTraverseType order, GTraverseFlags flags, void* data);
	GNode* g_node_find_child (GNode* node, GTraverseFlags flags, void* data);
	GNode* g_node_first_sibling (GNode* node);
	GNode* g_node_get_root (GNode* node);
	GNode* g_node_insert (GNode* parent, int position, GNode* node);
	GNode* g_node_insert_after (GNode* parent, GNode* sibling, GNode* node);
	GNode* g_node_insert_before (GNode* parent, GNode* sibling, GNode* node);
	int g_node_is_ancestor (GNode* node, GNode* descendant);
	GNode* g_node_last_child (GNode* node);
	GNode* g_node_last_sibling (GNode* node);
	uint g_node_max_height (GNode* root);
	uint g_node_n_children (GNode* node);
	uint g_node_n_nodes (GNode* root, GTraverseFlags flags);
	GNode* g_node_nth_child (GNode* node, uint n);
	GNode* g_node_prepend (GNode* parent, GNode* node);
	void g_node_reverse_children (GNode* node);
	void g_node_traverse (GNode* root, GTraverseType order, GTraverseFlags flags, int maxDepth, GNodeTraverseFunc func, void* data);
	void g_node_unlink (GNode* node);
	GNode* g_node_new (void* data);

	// glib.Once

	void* g_once_impl (GOnce* once, GThreadFunc func, void* arg);
	int g_once_init_enter (void* location);
	void g_once_init_leave (void* location, size_t result);

	// glib.OptionContext

	void g_option_context_add_group (GOptionContext* context, GOptionGroup* group);
	void g_option_context_add_main_entries (GOptionContext* context, GOptionEntry* entries, const(char)* translationDomain);
	void g_option_context_free (GOptionContext* context);
	const(char)* g_option_context_get_description (GOptionContext* context);
	char* g_option_context_get_help (GOptionContext* context, int mainHelp, GOptionGroup* group);
	int g_option_context_get_help_enabled (GOptionContext* context);
	int g_option_context_get_ignore_unknown_options (GOptionContext* context);
	GOptionGroup* g_option_context_get_main_group (GOptionContext* context);
	int g_option_context_get_strict_posix (GOptionContext* context);
	const(char)* g_option_context_get_summary (GOptionContext* context);
	int g_option_context_parse (GOptionContext* context, int* argc, char*** argv, GError** err);
	int g_option_context_parse_strv (GOptionContext* context, char*** arguments, GError** err);
	void g_option_context_set_description (GOptionContext* context, const(char)* description);
	void g_option_context_set_help_enabled (GOptionContext* context, int helpEnabled);
	void g_option_context_set_ignore_unknown_options (GOptionContext* context, int ignoreUnknown);
	void g_option_context_set_main_group (GOptionContext* context, GOptionGroup* group);
	void g_option_context_set_strict_posix (GOptionContext* context, int strictPosix);
	void g_option_context_set_summary (GOptionContext* context, const(char)* summary);
	void g_option_context_set_translate_func (GOptionContext* context, GTranslateFunc func, void* data, GDestroyNotify destroyNotify);
	void g_option_context_set_translation_domain (GOptionContext* context, const(char)* domain);
	GOptionContext* g_option_context_new (const(char)* parameterString);
	GQuark g_option_error_quark ();

	// glib.OptionGroup

	GOptionGroup* g_option_group_new (const(char)* name, const(char)* description, const(char)* helpDescription, void* userData, GDestroyNotify destroy);
	void g_option_group_add_entries (GOptionGroup* group, GOptionEntry* entries);
	void g_option_group_free (GOptionGroup* group);
	GOptionGroup* g_option_group_ref (GOptionGroup* group);
	void g_option_group_set_error_hook (GOptionGroup* group, GOptionErrorFunc errorFunc);
	void g_option_group_set_parse_hooks (GOptionGroup* group, GOptionParseFunc preParseFunc, GOptionParseFunc postParseFunc);
	void g_option_group_set_translate_func (GOptionGroup* group, GTranslateFunc func, void* data, GDestroyNotify destroyNotify);
	void g_option_group_set_translation_domain (GOptionGroup* group, const(char)* domain);
	void g_option_group_unref (GOptionGroup* group);

	// glib.Pattern

	int g_pattern_spec_equal (GPatternSpec* pspec1, GPatternSpec* pspec2);
	void g_pattern_spec_free (GPatternSpec* pspec);
	GPatternSpec* g_pattern_spec_new (const(char)* pattern);
	int g_pattern_match (GPatternSpec* pspec, uint stringLength, const(char)* str, const(char)* stringReversed);
	int g_pattern_match_simple (const(char)* pattern, const(char)* str);
	int g_pattern_match_string (GPatternSpec* pspec, const(char)* str);

	// glib.Private

	void* g_private_get (GPrivate* key);
	void g_private_replace (GPrivate* key, void* value);
	void g_private_set (GPrivate* key, void* value);

	// glib.PtrArray

	void g_ptr_array_add (GPtrArray* array, void* data);
	void g_ptr_array_foreach (GPtrArray* array, GFunc func, void* userData);
	void** g_ptr_array_free (GPtrArray* array, int freeSeg);
	void g_ptr_array_insert (GPtrArray* array, int index, void* data);
	GPtrArray* g_ptr_array_new ();
	GPtrArray* g_ptr_array_new_full (uint reservedSize, GDestroyNotify elementFreeFunc);
	GPtrArray* g_ptr_array_new_with_free_func (GDestroyNotify elementFreeFunc);
	GPtrArray* g_ptr_array_ref (GPtrArray* array);
	int g_ptr_array_remove (GPtrArray* array, void* data);
	int g_ptr_array_remove_fast (GPtrArray* array, void* data);
	void* g_ptr_array_remove_index (GPtrArray* array, uint index);
	void* g_ptr_array_remove_index_fast (GPtrArray* array, uint index);
	GPtrArray* g_ptr_array_remove_range (GPtrArray* array, uint index, uint length);
	void g_ptr_array_set_free_func (GPtrArray* array, GDestroyNotify elementFreeFunc);
	void g_ptr_array_set_size (GPtrArray* array, int length);
	GPtrArray* g_ptr_array_sized_new (uint reservedSize);
	void g_ptr_array_sort (GPtrArray* array, GCompareFunc compareFunc);
	void g_ptr_array_sort_with_data (GPtrArray* array, GCompareDataFunc compareFunc, void* userData);
	void g_ptr_array_unref (GPtrArray* array);

	// glib.QueueG

	void g_queue_clear (GQueue* queue);
	GQueue* g_queue_copy (GQueue* queue);
	void g_queue_delete_link (GQueue* queue, GList* link);
	GList* g_queue_find (GQueue* queue, void* data);
	GList* g_queue_find_custom (GQueue* queue, void* data, GCompareFunc func);
	void g_queue_foreach (GQueue* queue, GFunc func, void* userData);
	void g_queue_free (GQueue* queue);
	void g_queue_free_full (GQueue* queue, GDestroyNotify freeFunc);
	uint g_queue_get_length (GQueue* queue);
	int g_queue_index (GQueue* queue, void* data);
	void g_queue_init (GQueue* queue);
	void g_queue_insert_after (GQueue* queue, GList* sibling, void* data);
	void g_queue_insert_before (GQueue* queue, GList* sibling, void* data);
	void g_queue_insert_sorted (GQueue* queue, void* data, GCompareDataFunc func, void* userData);
	int g_queue_is_empty (GQueue* queue);
	int g_queue_link_index (GQueue* queue, GList* link);
	void* g_queue_peek_head (GQueue* queue);
	GList* g_queue_peek_head_link (GQueue* queue);
	void* g_queue_peek_nth (GQueue* queue, uint n);
	GList* g_queue_peek_nth_link (GQueue* queue, uint n);
	void* g_queue_peek_tail (GQueue* queue);
	GList* g_queue_peek_tail_link (GQueue* queue);
	void* g_queue_pop_head (GQueue* queue);
	GList* g_queue_pop_head_link (GQueue* queue);
	void* g_queue_pop_nth (GQueue* queue, uint n);
	GList* g_queue_pop_nth_link (GQueue* queue, uint n);
	void* g_queue_pop_tail (GQueue* queue);
	GList* g_queue_pop_tail_link (GQueue* queue);
	void g_queue_push_head (GQueue* queue, void* data);
	void g_queue_push_head_link (GQueue* queue, GList* link);
	void g_queue_push_nth (GQueue* queue, void* data, int n);
	void g_queue_push_nth_link (GQueue* queue, int n, GList* link);
	void g_queue_push_tail (GQueue* queue, void* data);
	void g_queue_push_tail_link (GQueue* queue, GList* link);
	int g_queue_remove (GQueue* queue, void* data);
	uint g_queue_remove_all (GQueue* queue, void* data);
	void g_queue_reverse (GQueue* queue);
	void g_queue_sort (GQueue* queue, GCompareDataFunc compareFunc, void* userData);
	void g_queue_unlink (GQueue* queue, GList* link);
	GQueue* g_queue_new ();

	// glib.RWLock

	void g_rw_lock_clear (GRWLock* rwLock);
	void g_rw_lock_init (GRWLock* rwLock);
	void g_rw_lock_reader_lock (GRWLock* rwLock);
	int g_rw_lock_reader_trylock (GRWLock* rwLock);
	void g_rw_lock_reader_unlock (GRWLock* rwLock);
	void g_rw_lock_writer_lock (GRWLock* rwLock);
	int g_rw_lock_writer_trylock (GRWLock* rwLock);
	void g_rw_lock_writer_unlock (GRWLock* rwLock);

	// glib.RandG

	GRand* g_rand_copy (GRand* rand);
	double g_rand_double (GRand* rand);
	double g_rand_double_range (GRand* rand, double begin, double end);
	void g_rand_free (GRand* rand);
	uint g_rand_int (GRand* rand);
	int g_rand_int_range (GRand* rand, int begin, int end);
	void g_rand_set_seed (GRand* rand, uint seed);
	void g_rand_set_seed_array (GRand* rand, uint* seed, uint seedLength);
	GRand* g_rand_new ();
	GRand* g_rand_new_with_seed (uint seed);
	GRand* g_rand_new_with_seed_array (uint* seed, uint seedLength);
	double g_random_double ();
	double g_random_double_range (double begin, double end);
	uint g_random_int ();
	int g_random_int_range (int begin, int end);
	void g_random_set_seed (uint seed);

	// glib.RecMutex

	void g_rec_mutex_clear (GRecMutex* recMutex);
	void g_rec_mutex_init (GRecMutex* recMutex);
	void g_rec_mutex_lock (GRecMutex* recMutex);
	int g_rec_mutex_trylock (GRecMutex* recMutex);
	void g_rec_mutex_unlock (GRecMutex* recMutex);

	// glib.Regex

	GRegex* g_regex_new (const(char)* pattern, GRegexCompileFlags compileOptions, GRegexMatchFlags matchOptions, GError** err);
	int g_regex_get_capture_count (GRegex* regex);
	GRegexCompileFlags g_regex_get_compile_flags (GRegex* regex);
	int g_regex_get_has_cr_or_lf (GRegex* regex);
	GRegexMatchFlags g_regex_get_match_flags (GRegex* regex);
	int g_regex_get_max_backref (GRegex* regex);
	int g_regex_get_max_lookbehind (GRegex* regex);
	const(char)* g_regex_get_pattern (GRegex* regex);
	int g_regex_get_string_number (GRegex* regex, const(char)* name);
	int g_regex_match (GRegex* regex, const(char)* str, GRegexMatchFlags matchOptions, GMatchInfo** matchInfo);
	int g_regex_match_all (GRegex* regex, const(char)* str, GRegexMatchFlags matchOptions, GMatchInfo** matchInfo);
	int g_regex_match_all_full (GRegex* regex, char* str, ptrdiff_t stringLen, int startPosition, GRegexMatchFlags matchOptions, GMatchInfo** matchInfo, GError** err);
	int g_regex_match_full (GRegex* regex, char* str, ptrdiff_t stringLen, int startPosition, GRegexMatchFlags matchOptions, GMatchInfo** matchInfo, GError** err);
	GRegex* g_regex_ref (GRegex* regex);
	char* g_regex_replace (GRegex* regex, char* str, ptrdiff_t stringLen, int startPosition, const(char)* replacement, GRegexMatchFlags matchOptions, GError** err);
	char* g_regex_replace_eval (GRegex* regex, char* str, ptrdiff_t stringLen, int startPosition, GRegexMatchFlags matchOptions, GRegexEvalCallback eval, void* userData, GError** err);
	char* g_regex_replace_literal (GRegex* regex, char* str, ptrdiff_t stringLen, int startPosition, const(char)* replacement, GRegexMatchFlags matchOptions, GError** err);
	char** g_regex_split (GRegex* regex, const(char)* str, GRegexMatchFlags matchOptions);
	char** g_regex_split_full (GRegex* regex, char* str, ptrdiff_t stringLen, int startPosition, GRegexMatchFlags matchOptions, int maxTokens, GError** err);
	void g_regex_unref (GRegex* regex);
	int g_regex_check_replacement (const(char)* replacement, int* hasReferences, GError** err);
	GQuark g_regex_error_quark ();
	char* g_regex_escape_nul (const(char)* str, int length);
	char* g_regex_escape_string (char* str, int length);
	int g_regex_match_simple (const(char)* pattern, const(char)* str, GRegexCompileFlags compileOptions, GRegexMatchFlags matchOptions);
	char** g_regex_split_simple (const(char)* pattern, const(char)* str, GRegexCompileFlags compileOptions, GRegexMatchFlags matchOptions);

	// glib.ListSG

	GSList* g_slist_alloc ();
	GSList* g_slist_append (GSList* list, void* data);
	GSList* g_slist_concat (GSList* list1, GSList* list2);
	GSList* g_slist_copy (GSList* list);
	GSList* g_slist_copy_deep (GSList* list, GCopyFunc func, void* userData);
	GSList* g_slist_delete_link (GSList* list, GSList* link);
	GSList* g_slist_find (GSList* list, void* data);
	GSList* g_slist_find_custom (GSList* list, void* data, GCompareFunc func);
	void g_slist_foreach (GSList* list, GFunc func, void* userData);
	void g_slist_free (GSList* list);
	void g_slist_free_1 (GSList* list);
	void g_slist_free_full (GSList* list, GDestroyNotify freeFunc);
	int g_slist_index (GSList* list, void* data);
	GSList* g_slist_insert (GSList* list, void* data, int position);
	GSList* g_slist_insert_before (GSList* slist, GSList* sibling, void* data);
	GSList* g_slist_insert_sorted (GSList* list, void* data, GCompareFunc func);
	GSList* g_slist_insert_sorted_with_data (GSList* list, void* data, GCompareDataFunc func, void* userData);
	GSList* g_slist_last (GSList* list);
	uint g_slist_length (GSList* list);
	GSList* g_slist_nth (GSList* list, uint n);
	void* g_slist_nth_data (GSList* list, uint n);
	int g_slist_position (GSList* list, GSList* llink);
	GSList* g_slist_prepend (GSList* list, void* data);
	GSList* g_slist_remove (GSList* list, void* data);
	GSList* g_slist_remove_all (GSList* list, void* data);
	GSList* g_slist_remove_link (GSList* list, GSList* link);
	GSList* g_slist_reverse (GSList* list);
	GSList* g_slist_sort (GSList* list, GCompareFunc compareFunc);
	GSList* g_slist_sort_with_data (GSList* list, GCompareDataFunc compareFunc, void* userData);

	// glib.ScannerG

	uint g_scanner_cur_line (GScanner* scanner);
	uint g_scanner_cur_position (GScanner* scanner);
	GTokenType g_scanner_cur_token (GScanner* scanner);
	GTokenValue g_scanner_cur_value (GScanner* scanner);
	void g_scanner_destroy (GScanner* scanner);
	int g_scanner_eof (GScanner* scanner);
	void g_scanner_error (GScanner* scanner, const(char)* format, ... );
	GTokenType g_scanner_get_next_token (GScanner* scanner);
	void g_scanner_input_file (GScanner* scanner, int inputFd);
	void g_scanner_input_text (GScanner* scanner, const(char)* text, uint textLen);
	void* g_scanner_lookup_symbol (GScanner* scanner, const(char)* symbol);
	GTokenType g_scanner_peek_next_token (GScanner* scanner);
	void g_scanner_scope_add_symbol (GScanner* scanner, uint scopeId, const(char)* symbol, void* value);
	void g_scanner_scope_foreach_symbol (GScanner* scanner, uint scopeId, GHFunc func, void* userData);
	void* g_scanner_scope_lookup_symbol (GScanner* scanner, uint scopeId, const(char)* symbol);
	void g_scanner_scope_remove_symbol (GScanner* scanner, uint scopeId, const(char)* symbol);
	uint g_scanner_set_scope (GScanner* scanner, uint scopeId);
	void g_scanner_sync_file_offset (GScanner* scanner);
	void g_scanner_unexp_token (GScanner* scanner, GTokenType expectedToken, const(char)* identifierSpec, const(char)* symbolSpec, const(char)* symbolName, const(char)* message, int isError);
	void g_scanner_warn (GScanner* scanner, const(char)* format, ... );
	GScanner* g_scanner_new (GScannerConfig* configTempl);

	// glib.Sequence

	GSequenceIter* g_sequence_append (GSequence* seq, void* data);
	void g_sequence_foreach (GSequence* seq, GFunc func, void* userData);
	void g_sequence_free (GSequence* seq);
	GSequenceIter* g_sequence_get_begin_iter (GSequence* seq);
	GSequenceIter* g_sequence_get_end_iter (GSequence* seq);
	GSequenceIter* g_sequence_get_iter_at_pos (GSequence* seq, int pos);
	int g_sequence_get_length (GSequence* seq);
	GSequenceIter* g_sequence_insert_sorted (GSequence* seq, void* data, GCompareDataFunc cmpFunc, void* cmpData);
	GSequenceIter* g_sequence_insert_sorted_iter (GSequence* seq, void* data, GSequenceIterCompareFunc iterCmp, void* cmpData);
	GSequenceIter* g_sequence_lookup (GSequence* seq, void* data, GCompareDataFunc cmpFunc, void* cmpData);
	GSequenceIter* g_sequence_lookup_iter (GSequence* seq, void* data, GSequenceIterCompareFunc iterCmp, void* cmpData);
	GSequenceIter* g_sequence_prepend (GSequence* seq, void* data);
	GSequenceIter* g_sequence_search (GSequence* seq, void* data, GCompareDataFunc cmpFunc, void* cmpData);
	GSequenceIter* g_sequence_search_iter (GSequence* seq, void* data, GSequenceIterCompareFunc iterCmp, void* cmpData);
	void g_sequence_sort (GSequence* seq, GCompareDataFunc cmpFunc, void* cmpData);
	void g_sequence_sort_iter (GSequence* seq, GSequenceIterCompareFunc cmpFunc, void* cmpData);
	void g_sequence_foreach_range (GSequenceIter* begin, GSequenceIter* end, GFunc func, void* userData);
	void* g_sequence_get (GSequenceIter* iter);
	GSequenceIter* g_sequence_insert_before (GSequenceIter* iter, void* data);
	void g_sequence_move (GSequenceIter* src, GSequenceIter* dest);
	void g_sequence_move_range (GSequenceIter* dest, GSequenceIter* begin, GSequenceIter* end);
	GSequence* g_sequence_new (GDestroyNotify dataDestroy);
	GSequenceIter* g_sequence_range_get_midpoint (GSequenceIter* begin, GSequenceIter* end);
	void g_sequence_remove (GSequenceIter* iter);
	void g_sequence_remove_range (GSequenceIter* begin, GSequenceIter* end);
	void g_sequence_set (GSequenceIter* iter, void* data);
	void g_sequence_sort_changed (GSequenceIter* iter, GCompareDataFunc cmpFunc, void* cmpData);
	void g_sequence_sort_changed_iter (GSequenceIter* iter, GSequenceIterCompareFunc iterCmp, void* cmpData);
	void g_sequence_swap (GSequenceIter* a, GSequenceIter* b);

	// glib.SequenceIter

	int g_sequence_iter_compare (GSequenceIter* a, GSequenceIter* b);
	int g_sequence_iter_get_position (GSequenceIter* iter);
	GSequence* g_sequence_iter_get_sequence (GSequenceIter* iter);
	int g_sequence_iter_is_begin (GSequenceIter* iter);
	int g_sequence_iter_is_end (GSequenceIter* iter);
	GSequenceIter* g_sequence_iter_move (GSequenceIter* iter, int delta);
	GSequenceIter* g_sequence_iter_next (GSequenceIter* iter);
	GSequenceIter* g_sequence_iter_prev (GSequenceIter* iter);

	// glib.Source

	GSource* g_source_new (GSourceFuncs* sourceFuncs, uint structSize);
	void g_source_add_child_source (GSource* source, GSource* childSource);
	void g_source_add_poll (GSource* source, GPollFD* fd);
	void* g_source_add_unix_fd (GSource* source, int fd, GIOCondition events);
	uint g_source_attach (GSource* source, GMainContext* context);
	void g_source_destroy (GSource* source);
	int g_source_get_can_recurse (GSource* source);
	GMainContext* g_source_get_context (GSource* source);
	void g_source_get_current_time (GSource* source, GTimeVal* timeval);
	uint g_source_get_id (GSource* source);
	const(char)* g_source_get_name (GSource* source);
	int g_source_get_priority (GSource* source);
	long g_source_get_ready_time (GSource* source);
	long g_source_get_time (GSource* source);
	int g_source_is_destroyed (GSource* source);
	void g_source_modify_unix_fd (GSource* source, void* tag, GIOCondition newEvents);
	GIOCondition g_source_query_unix_fd (GSource* source, void* tag);
	GSource* g_source_ref (GSource* source);
	void g_source_remove_child_source (GSource* source, GSource* childSource);
	void g_source_remove_poll (GSource* source, GPollFD* fd);
	void g_source_remove_unix_fd (GSource* source, void* tag);
	void g_source_set_callback (GSource* source, GSourceFunc func, void* data, GDestroyNotify notify);
	void g_source_set_callback_indirect (GSource* source, void* callbackData, GSourceCallbackFuncs* callbackFuncs);
	void g_source_set_can_recurse (GSource* source, int canRecurse);
	void g_source_set_funcs (GSource* source, GSourceFuncs* funcs);
	void g_source_set_name (GSource* source, const(char)* name);
	void g_source_set_priority (GSource* source, int priority);
	void g_source_set_ready_time (GSource* source, long readyTime);
	void g_source_unref (GSource* source);
	int g_source_remove (uint tag);
	int g_source_remove_by_funcs_user_data (GSourceFuncs* funcs, void* userData);
	int g_source_remove_by_user_data (void* userData);
	void g_source_set_name_by_id (uint tag, const(char)* name);

	// glib.StringG

	GString* g_string_append (GString* str, const(char)* val);
	GString* g_string_append_c (GString* str, char c);
	GString* g_string_append_len (GString* str, const(char)* val, ptrdiff_t len);
	void g_string_append_printf (GString* str, const(char)* format, ... );
	GString* g_string_append_unichar (GString* str, dchar wc);
	GString* g_string_append_uri_escaped (GString* str, const(char)* unescaped, const(char)* reservedCharsAllowed, int allowUtf8);
	void g_string_append_vprintf (GString* str, const(char)* format, void* args);
	GString* g_string_ascii_down (GString* str);
	GString* g_string_ascii_up (GString* str);
	GString* g_string_assign (GString* str, const(char)* rval);
	GString* g_string_down (GString* str);
	int g_string_equal (GString* v, GString* v2);
	GString* g_string_erase (GString* str, ptrdiff_t pos, ptrdiff_t len);
	char* g_string_free (GString* str, int freeSegment);
	GBytes* g_string_free_to_bytes (GString* str);
	uint g_string_hash (GString* str);
	GString* g_string_insert (GString* str, ptrdiff_t pos, const(char)* val);
	GString* g_string_insert_c (GString* str, ptrdiff_t pos, char c);
	GString* g_string_insert_len (GString* str, ptrdiff_t pos, const(char)* val, ptrdiff_t len);
	GString* g_string_insert_unichar (GString* str, ptrdiff_t pos, dchar wc);
	GString* g_string_overwrite (GString* str, size_t pos, const(char)* val);
	GString* g_string_overwrite_len (GString* str, size_t pos, const(char)* val, ptrdiff_t len);
	GString* g_string_prepend (GString* str, const(char)* val);
	GString* g_string_prepend_c (GString* str, char c);
	GString* g_string_prepend_len (GString* str, const(char)* val, ptrdiff_t len);
	GString* g_string_prepend_unichar (GString* str, dchar wc);
	void g_string_printf (GString* str, const(char)* format, ... );
	GString* g_string_set_size (GString* str, size_t len);
	GString* g_string_truncate (GString* str, size_t len);
	GString* g_string_up (GString* str);
	void g_string_vprintf (GString* str, const(char)* format, void* args);
	GString* g_string_new (const(char)* init);
	GString* g_string_new_len (const(char)* init, ptrdiff_t len);
	GString* g_string_sized_new (size_t dflSize);

	// glib.StringChunk

	void g_string_chunk_clear (GStringChunk* chunk);
	void g_string_chunk_free (GStringChunk* chunk);
	char* g_string_chunk_insert (GStringChunk* chunk, const(char)* str);
	char* g_string_chunk_insert_const (GStringChunk* chunk, const(char)* str);
	char* g_string_chunk_insert_len (GStringChunk* chunk, const(char)* str, ptrdiff_t len);
	GStringChunk* g_string_chunk_new (size_t size);

	// glib.TestLogBuffer

	void g_test_log_buffer_free (GTestLogBuffer* tbuffer);
	GTestLogMsg* g_test_log_buffer_pop (GTestLogBuffer* tbuffer);
	void g_test_log_buffer_push (GTestLogBuffer* tbuffer, uint nBytes, ubyte* bytes);
	GTestLogBuffer* g_test_log_buffer_new ();

	// glib.TestLogMsg

	void g_test_log_msg_free (GTestLogMsg* tmsg);

	// glib.TestSuite

	void g_test_suite_add (GTestSuite* suite, GTestCase* testCase);
	void g_test_suite_add_suite (GTestSuite* suite, GTestSuite* nestedsuite);

	// glib.Thread

	GThread* g_thread_new (const(char)* name, GThreadFunc func, void* data);
	GThread* g_thread_try_new (const(char)* name, GThreadFunc func, void* data, GError** err);
	void* g_thread_join (GThread* thread);
	GThread* g_thread_ref (GThread* thread);
	void g_thread_unref (GThread* thread);
	GQuark g_thread_error_quark ();
	void g_thread_exit (void* retval);
	GThread* g_thread_self ();
	void g_thread_yield ();
	void g_bit_lock (int* address, int lockBit);
	int g_bit_trylock (int* address, int lockBit);
	void g_bit_unlock (int* address, int lockBit);
	uint g_get_num_processors ();
	void g_pointer_bit_lock (void* address, int lockBit);
	int g_pointer_bit_trylock (void* address, int lockBit);
	void g_pointer_bit_unlock (void* address, int lockBit);

	// glib.ThreadPool

	void g_thread_pool_free (GThreadPool* pool, int immediate, int wait);
	int g_thread_pool_get_max_threads (GThreadPool* pool);
	uint g_thread_pool_get_num_threads (GThreadPool* pool);
	int g_thread_pool_move_to_front (GThreadPool* pool, void* data);
	int g_thread_pool_push (GThreadPool* pool, void* data, GError** err);
	int g_thread_pool_set_max_threads (GThreadPool* pool, int maxThreads, GError** err);
	void g_thread_pool_set_sort_function (GThreadPool* pool, GCompareDataFunc func, void* userData);
	uint g_thread_pool_unprocessed (GThreadPool* pool);
	uint g_thread_pool_get_max_idle_time ();
	int g_thread_pool_get_max_unused_threads ();
	uint g_thread_pool_get_num_unused_threads ();
	GThreadPool* g_thread_pool_new (GFunc func, void* userData, int maxThreads, int exclusive, GError** err);
	void g_thread_pool_set_max_idle_time (uint interval);
	void g_thread_pool_set_max_unused_threads (int maxThreads);
	void g_thread_pool_stop_unused_threads ();

	// glib.TimeVal

	void g_time_val_add (GTimeVal* time, glong microseconds);
	char* g_time_val_to_iso8601 (GTimeVal* time);
	int g_time_val_from_iso8601 (const(char)* isoDate, GTimeVal* time);
	void g_get_current_time (GTimeVal* result);
	long g_get_monotonic_time ();
	long g_get_real_time ();
	void g_usleep (gulong microseconds);

	// glib.TimeZone

	GTimeZone* g_time_zone_new (const(char)* identifier);
	GTimeZone* g_time_zone_new_local ();
	GTimeZone* g_time_zone_new_utc ();
	int g_time_zone_adjust_time (GTimeZone* tz, GTimeType type, long* time);
	int g_time_zone_find_interval (GTimeZone* tz, GTimeType type, long time);
	const(char)* g_time_zone_get_abbreviation (GTimeZone* tz, int interval);
	int g_time_zone_get_offset (GTimeZone* tz, int interval);
	int g_time_zone_is_dst (GTimeZone* tz, int interval);
	GTimeZone* g_time_zone_ref (GTimeZone* tz);
	void g_time_zone_unref (GTimeZone* tz);

	// glib.Timer

	void g_timer_continue (GTimer* timer);
	void g_timer_destroy (GTimer* timer);
	double g_timer_elapsed (GTimer* timer, gulong* microseconds);
	void g_timer_reset (GTimer* timer);
	void g_timer_start (GTimer* timer);
	void g_timer_stop (GTimer* timer);
	GTimer* g_timer_new ();

	// glib.TrashStack

	uint g_trash_stack_height (GTrashStack** stackP);
	void* g_trash_stack_peek (GTrashStack** stackP);
	void* g_trash_stack_pop (GTrashStack** stackP);
	void g_trash_stack_push (GTrashStack** stackP, void* dataP);

	// glib.BBTree

	void g_tree_destroy (GTree* tree);
	void g_tree_foreach (GTree* tree, GTraverseFunc func, void* userData);
	int g_tree_height (GTree* tree);
	void g_tree_insert (GTree* tree, void* key, void* value);
	void* g_tree_lookup (GTree* tree, void* key);
	int g_tree_lookup_extended (GTree* tree, void* lookupKey, void** origKey, void** value);
	int g_tree_nnodes (GTree* tree);
	GTree* g_tree_ref (GTree* tree);
	int g_tree_remove (GTree* tree, void* key);
	void g_tree_replace (GTree* tree, void* key, void* value);
	void* g_tree_search (GTree* tree, GCompareFunc searchFunc, void* userData);
	int g_tree_steal (GTree* tree, void* key);
	void g_tree_traverse (GTree* tree, GTraverseFunc traverseFunc, GTraverseType traverseType, void* userData);
	void g_tree_unref (GTree* tree);
	GTree* g_tree_new (GCompareFunc keyCompareFunc);
	GTree* g_tree_new_full (GCompareDataFunc keyCompareFunc, void* keyCompareData, GDestroyNotify keyDestroyFunc, GDestroyNotify valueDestroyFunc);
	GTree* g_tree_new_with_data (GCompareDataFunc keyCompareFunc, void* keyCompareData);

	// glib.Variant

	GVariant* g_variant_new (const(char)* formatString, ... );
	GVariant* g_variant_new_array (GVariantType* childType, GVariant** children, size_t nChildren);
	GVariant* g_variant_new_boolean (int value);
	GVariant* g_variant_new_byte (char value);
	GVariant* g_variant_new_bytestring (char* str);
	GVariant* g_variant_new_bytestring_array (char** strv, ptrdiff_t length);
	GVariant* g_variant_new_dict_entry (GVariant* key, GVariant* value);
	GVariant* g_variant_new_double (double value);
	GVariant* g_variant_new_fixed_array (GVariantType* elementType, void* elements, size_t nElements, size_t elementSize);
	GVariant* g_variant_new_from_bytes (GVariantType* type, GBytes* bytes, int trusted);
	GVariant* g_variant_new_from_data (GVariantType* type, void* data, size_t size, int trusted, GDestroyNotify notify, void* userData);
	GVariant* g_variant_new_handle (int value);
	GVariant* g_variant_new_int16 (short value);
	GVariant* g_variant_new_int32 (int value);
	GVariant* g_variant_new_int64 (long value);
	GVariant* g_variant_new_maybe (GVariantType* childType, GVariant* child);
	GVariant* g_variant_new_object_path (const(char)* objectPath);
	GVariant* g_variant_new_objv (char** strv, ptrdiff_t length);
	GVariant* g_variant_new_parsed (const(char)* format, ... );
	GVariant* g_variant_new_parsed_va (const(char)* format, void** app);
	GVariant* g_variant_new_printf (const(char)* formatString, ... );
	GVariant* g_variant_new_signature (const(char)* signature);
	GVariant* g_variant_new_string (const(char)* str);
	GVariant* g_variant_new_strv (char** strv, ptrdiff_t length);
	GVariant* g_variant_new_take_string (char* str);
	GVariant* g_variant_new_tuple (GVariant** children, size_t nChildren);
	GVariant* g_variant_new_uint16 (ushort value);
	GVariant* g_variant_new_uint32 (uint value);
	GVariant* g_variant_new_uint64 (ulong value);
	GVariant* g_variant_new_va (const(char)* formatString, char** endptr, void** app);
	GVariant* g_variant_new_variant (GVariant* value);
	GVariant* g_variant_byteswap (GVariant* value);
	int g_variant_check_format_string (GVariant* value, const(char)* formatString, int copyOnly);
	GVariantClass g_variant_classify (GVariant* value);
	int g_variant_compare (void* one, void* two);
	char* g_variant_dup_bytestring (GVariant* value, size_t* length);
	char** g_variant_dup_bytestring_array (GVariant* value, size_t* length);
	char** g_variant_dup_objv (GVariant* value, size_t* length);
	char* g_variant_dup_string (GVariant* value, size_t* length);
	char** g_variant_dup_strv (GVariant* value, size_t* length);
	int g_variant_equal (void* one, void* two);
	void g_variant_get (GVariant* value, const(char)* formatString, ... );
	int g_variant_get_boolean (GVariant* value);
	char g_variant_get_byte (GVariant* value);
	char* g_variant_get_bytestring (GVariant* value);
	char** g_variant_get_bytestring_array (GVariant* value, size_t* length);
	void g_variant_get_child (GVariant* value, size_t index, const(char)* formatString, ... );
	GVariant* g_variant_get_child_value (GVariant* value, size_t index);
	void* g_variant_get_data (GVariant* value);
	GBytes* g_variant_get_data_as_bytes (GVariant* value);
	double g_variant_get_double (GVariant* value);
	void* g_variant_get_fixed_array (GVariant* value, size_t* nElements, size_t elementSize);
	int g_variant_get_handle (GVariant* value);
	short g_variant_get_int16 (GVariant* value);
	int g_variant_get_int32 (GVariant* value);
	long g_variant_get_int64 (GVariant* value);
	GVariant* g_variant_get_maybe (GVariant* value);
	GVariant* g_variant_get_normal_form (GVariant* value);
	char** g_variant_get_objv (GVariant* value, size_t* length);
	size_t g_variant_get_size (GVariant* value);
	const(char)* g_variant_get_string (GVariant* value, size_t* length);
	char** g_variant_get_strv (GVariant* value, size_t* length);
	GVariantType* g_variant_get_type (GVariant* value);
	const(char)* g_variant_get_type_string (GVariant* value);
	ushort g_variant_get_uint16 (GVariant* value);
	uint g_variant_get_uint32 (GVariant* value);
	ulong g_variant_get_uint64 (GVariant* value);
	void g_variant_get_va (GVariant* value, const(char)* formatString, char** endptr, void** app);
	GVariant* g_variant_get_variant (GVariant* value);
	uint g_variant_hash (void* value);
	int g_variant_is_container (GVariant* value);
	int g_variant_is_floating (GVariant* value);
	int g_variant_is_normal_form (GVariant* value);
	int g_variant_is_of_type (GVariant* value, GVariantType* type);
	GVariantIter* g_variant_iter_new (GVariant* value);
	int g_variant_lookup (GVariant* dictionary, const(char)* key, const(char)* formatString, ... );
	GVariant* g_variant_lookup_value (GVariant* dictionary, const(char)* key, GVariantType* expectedType);
	size_t g_variant_n_children (GVariant* value);
	char* g_variant_print (GVariant* value, int typeAnnotate);
	GString* g_variant_print_string (GVariant* value, GString* str, int typeAnnotate);
	GVariant* g_variant_ref (GVariant* value);
	GVariant* g_variant_ref_sink (GVariant* value);
	void g_variant_store (GVariant* value, void* data);
	GVariant* g_variant_take_ref (GVariant* value);
	void g_variant_unref (GVariant* value);
	int g_variant_is_object_path (const(char)* str);
	int g_variant_is_signature (const(char)* str);
	GVariant* g_variant_parse (GVariantType* type, const(char)* text, const(char)* limit, char** endptr, GError** err);
	char* g_variant_parse_error_print_context (GError* error, const(char)* sourceStr);
	GQuark g_variant_parse_error_quark ();
	GQuark g_variant_parser_get_error_quark ();

	// glib.VariantBuilder

	GVariantBuilder* g_variant_builder_new (GVariantType* type);
	void g_variant_builder_add (GVariantBuilder* builder, const(char)* formatString, ... );
	void g_variant_builder_add_parsed (GVariantBuilder* builder, const(char)* format, ... );
	void g_variant_builder_add_value (GVariantBuilder* builder, GVariant* value);
	void g_variant_builder_clear (GVariantBuilder* builder);
	void g_variant_builder_close (GVariantBuilder* builder);
	GVariant* g_variant_builder_end (GVariantBuilder* builder);
	void g_variant_builder_init (GVariantBuilder* builder, GVariantType* type);
	void g_variant_builder_open (GVariantBuilder* builder, GVariantType* type);
	GVariantBuilder* g_variant_builder_ref (GVariantBuilder* builder);
	void g_variant_builder_unref (GVariantBuilder* builder);

	// glib.VariantDict

	GVariantDict* g_variant_dict_new (GVariant* fromAsv);
	void g_variant_dict_clear (GVariantDict* dict);
	int g_variant_dict_contains (GVariantDict* dict, const(char)* key);
	GVariant* g_variant_dict_end (GVariantDict* dict);
	void g_variant_dict_init (GVariantDict* dict, GVariant* fromAsv);
	void g_variant_dict_insert (GVariantDict* dict, const(char)* key, const(char)* formatString, ... );
	void g_variant_dict_insert_value (GVariantDict* dict, const(char)* key, GVariant* value);
	int g_variant_dict_lookup (GVariantDict* dict, const(char)* key, const(char)* formatString, ... );
	GVariant* g_variant_dict_lookup_value (GVariantDict* dict, const(char)* key, GVariantType* expectedType);
	GVariantDict* g_variant_dict_ref (GVariantDict* dict);
	int g_variant_dict_remove (GVariantDict* dict, const(char)* key);
	void g_variant_dict_unref (GVariantDict* dict);

	// glib.VariantIter

	GVariantIter* g_variant_iter_copy (GVariantIter* iter);
	void g_variant_iter_free (GVariantIter* iter);
	size_t g_variant_iter_init (GVariantIter* iter, GVariant* value);
	int g_variant_iter_loop (GVariantIter* iter, const(char)* formatString, ... );
	size_t g_variant_iter_n_children (GVariantIter* iter);
	int g_variant_iter_next (GVariantIter* iter, const(char)* formatString, ... );
	GVariant* g_variant_iter_next_value (GVariantIter* iter);

	// glib.VariantType

	GVariantType* g_variant_type_new (const(char)* typeString);
	GVariantType* g_variant_type_new_array (GVariantType* element);
	GVariantType* g_variant_type_new_dict_entry (GVariantType* key, GVariantType* value);
	GVariantType* g_variant_type_new_maybe (GVariantType* element);
	GVariantType* g_variant_type_new_tuple (GVariantType** items, int length);
	GVariantType* g_variant_type_copy (GVariantType* type);
	char* g_variant_type_dup_string (GVariantType* type);
	GVariantType* g_variant_type_element (GVariantType* type);
	int g_variant_type_equal (void* type1, void* type2);
	GVariantType* g_variant_type_first (GVariantType* type);
	void g_variant_type_free (GVariantType* type);
	size_t g_variant_type_get_string_length (GVariantType* type);
	uint g_variant_type_hash (void* type);
	int g_variant_type_is_array (GVariantType* type);
	int g_variant_type_is_basic (GVariantType* type);
	int g_variant_type_is_container (GVariantType* type);
	int g_variant_type_is_definite (GVariantType* type);
	int g_variant_type_is_dict_entry (GVariantType* type);
	int g_variant_type_is_maybe (GVariantType* type);
	int g_variant_type_is_subtype_of (GVariantType* type, GVariantType* supertype);
	int g_variant_type_is_tuple (GVariantType* type);
	int g_variant_type_is_variant (GVariantType* type);
	GVariantType* g_variant_type_key (GVariantType* type);
	size_t g_variant_type_n_items (GVariantType* type);
	GVariantType* g_variant_type_next (GVariantType* type);
	const(char)* g_variant_type_peek_string (GVariantType* type);
	GVariantType* g_variant_type_value (GVariantType* type);
	GVariantType* g_variant_type_checked_ (const(char)* arg0);
	int g_variant_type_string_is_valid (const(char)* typeString);
	int g_variant_type_string_scan (const(char)* str, const(char)* limit, char** endptr);

	// glib.Module

	int g_module_close (GModule* modul);
	void g_module_make_resident (GModule* modul);
	const(char)* g_module_name (GModule* modul);
	int g_module_symbol (GModule* modul, const(char)* symbolName, void** symbol);
	char* g_module_build_path (const(char)* directory, const(char)* moduleName);
	const(char)* g_module_error ();
	GModule* g_module_open (const(char)* fileName, GModuleFlags flags);
	int g_module_supported ();

	// glib.Base64

	size_t g_base64_decode_step (char* inn, size_t len, char* output, int* state, uint* save);
	char* g_base64_decode_inplace (char* text, size_t* outLen);
	char* g_base64_decode (const(char)* text, size_t* outLen);
	char* g_base64_encode (char* data, size_t len);
	size_t g_base64_encode_close (int breakLines, char* output, int* state, int* save);
	size_t g_base64_encode_step (char* inn, size_t len, int breakLines, char* output, int* state, int* save);

	// glib.Idle

	uint g_idle_add (GSourceFunc funct, void* data);
	uint g_idle_add_full (int priority, GSourceFunc funct, void* data, GDestroyNotify notify);
	int g_idle_remove_by_data (void* data);
	GSource* g_idle_source_new ();

	// glib.MemorySlice

	void* g_slice_alloc (size_t blockSize);
	void* g_slice_alloc0 (size_t blockSize);
	void* g_slice_copy (size_t blockSize, void* memBlock);
	void g_slice_free1 (size_t blockSize, void* memBlock);
	void g_slice_free_chain_with_offset (size_t blockSize, void* memChain, size_t nextOffset);
	long g_slice_get_config (GSliceConfig ckey);
	long* g_slice_get_config_state (GSliceConfig ckey, long address, uint* nValues);
	void g_slice_set_config (GSliceConfig ckey, long value);

	// glib.Spawn

	int g_spawn_async (const(char)* workingDirectory, char** argv, char** envp, GSpawnFlags flags, GSpawnChildSetupFunc childSetup, void* userData, GPid* childPid, GError** err);
	int g_spawn_async_with_pipes (const(char)* workingDirectory, char** argv, char** envp, GSpawnFlags flags, GSpawnChildSetupFunc childSetup, void* userData, GPid* childPid, int* standardInput, int* standardOutput, int* standardError, GError** err);
	int g_spawn_check_exit_status (int exitStatus, GError** err);
	void g_spawn_close_pid (GPid pid);
	int g_spawn_command_line_async (const(char)* commandLine, GError** err);
	int g_spawn_command_line_sync (const(char)* commandLine, char** standardOutput, char** standardError, int* exitStatus, GError** err);
	GQuark g_spawn_error_quark ();
	GQuark g_spawn_exit_error_quark ();
	int g_spawn_sync (const(char)* workingDirectory, char** argv, char** envp, GSpawnFlags flags, GSpawnChildSetupFunc childSetup, void* userData, char** standardOutput, char** standardError, int* exitStatus, GError** err);

	// glib.Str

	int g_ascii_digit_value (char c);
	char* g_ascii_dtostr (char* buffer, int bufLen, double d);
	char* g_ascii_formatd (char* buffer, int bufLen, const(char)* format, double d);
	int g_ascii_strcasecmp (const(char)* s1, const(char)* s2);
	char* g_ascii_strdown (const(char)* str, ptrdiff_t len);
	int g_ascii_strncasecmp (const(char)* s1, const(char)* s2, size_t n);
	double g_ascii_strtod (const(char)* nptr, char** endptr);
	long g_ascii_strtoll (const(char)* nptr, char** endptr, uint base);
	ulong g_ascii_strtoull (const(char)* nptr, char** endptr, uint base);
	char* g_ascii_strup (const(char)* str, ptrdiff_t len);
	char g_ascii_tolower (char c);
	char g_ascii_toupper (char c);
	int g_ascii_xdigit_value (char c);
	int g_fprintf (FILE* file, char* format, ... );
	int g_printf (char* format, ... );
	size_t g_printf_string_upper_bound (const(char)* format, void* args);
	int g_snprintf (char* str, gulong n, char* format, ... );
	int g_sprintf (char* str, char* format, ... );
	char* g_stpcpy (char* dest, const(char)* src);
	int g_str_has_prefix (const(char)* str, const(char)* prefix);
	int g_str_has_suffix (const(char)* str, const(char)* suffix);
	int g_str_is_ascii (const(char)* str);
	int g_str_match_string (const(char)* searchTerm, const(char)* potentialHit, int acceptAlternates);
	char* g_str_to_ascii (const(char)* str, const(char)* fromLocale);
	char** g_str_tokenize_and_fold (const(char)* str, const(char)* translitLocale, char*** asciiAlternates);
	char* g_strcanon (char* str, const(char)* validChars, char substitutor);
	int g_strcasecmp (const(char)* s1, const(char)* s2);
	char* g_strchomp (char* str);
	char* g_strchug (char* str);
	int g_strcmp0 (const(char)* str1, const(char)* str2);
	char* g_strcompress (const(char)* source);
	char* g_strconcat (const(char)* string1, ... );
	char* g_strdelimit (char* str, const(char)* delimiters, char newDelimiter);
	char* g_strdown (char* str);
	char* g_strdup (const(char)* str);
	char* g_strdup_printf (const(char)* format, ... );
	char* g_strdup_vprintf (const(char)* format, void* args);
	char** g_strdupv (char** strArray);
	const(char)* g_strerror (int errnum);
	char* g_strescape (const(char)* source, const(char)* exceptions);
	void g_strfreev (char** strArray);
	char* g_strjoin (const(char)* separator, ... );
	char* g_strjoinv (const(char)* separator, char** strArray);
	size_t g_strlcat (char* dest, const(char)* src, size_t destSize);
	size_t g_strlcpy (char* dest, const(char)* src, size_t destSize);
	int g_strncasecmp (const(char)* s1, const(char)* s2, uint n);
	char* g_strndup (const(char)* str, size_t n);
	char* g_strnfill (size_t length, char fillChar);
	char* g_strreverse (char* str);
	char* g_strrstr (const(char)* haystack, const(char)* needle);
	char* g_strrstr_len (const(char)* haystack, ptrdiff_t haystackLen, const(char)* needle);
	const(char)* g_strsignal (int signum);
	char** g_strsplit (const(char)* str, const(char)* delimiter, int maxTokens);
	char** g_strsplit_set (const(char)* str, const(char)* delimiters, int maxTokens);
	char* g_strstr_len (const(char)* haystack, ptrdiff_t haystackLen, const(char)* needle);
	double g_strtod (const(char)* nptr, char** endptr);
	char* g_strup (char* str);
	GType g_strv_get_type ();
	uint g_strv_length (char** strArray);
	int g_strv_contains (const(char)* strv, const(char)* str);
	int g_vasprintf (char** str, char* format, void* args);
	int g_vfprintf (FILE* file, char* format, void* args);
	int g_vprintf (char* format, void* args);
	int g_vsnprintf (char* str, gulong n, char* format, void* args);
	int g_vsprintf (char* str, char* format, void* args);

	// glib.Timeout

	uint g_timeout_add (uint interval, GSourceFunc funct, void* data);
	uint g_timeout_add_full (int priority, uint interval, GSourceFunc funct, void* data, GDestroyNotify notify);
	uint g_timeout_add_seconds (uint interval, GSourceFunc funct, void* data);
	uint g_timeout_add_seconds_full (int priority, uint interval, GSourceFunc funct, void* data, GDestroyNotify notify);
	GSource* g_timeout_source_new (uint interval);
	GSource* g_timeout_source_new_seconds (uint interval);

	// glib.Util

	char* g_build_filenamev (char** args);
	char* g_build_pathv (const(char)* separator, char** args);
	void g_atexit (GVoidFunc func);
	const(char)* g_basename (const(char)* fileName);
	int g_bit_nth_lsf (gulong mask, int nthBit);
	int g_bit_nth_msf (gulong mask, int nthBit);
	uint g_bit_storage (gulong number);
	char* g_build_path (const(char)* separator, const(char)* firstElement, ... );
	const(char)* g_environ_getenv (char** envp, const(char)* variable);
	char** g_environ_setenv (char** envp, const(char)* variable, const(char)* value, int overwrite);
	char** g_environ_unsetenv (char** envp, const(char)* variable);
	char* g_find_program_in_path (const(char)* program);
	char* g_format_size (ulong size);
	char* g_format_size_for_display (long size);
	char* g_format_size_full (ulong size, GFormatSizeFlags flags);
	const(char)* g_get_application_name ();
	char** g_get_environ ();
	char* g_get_current_dir ();
	const(char)* g_get_home_dir ();
	const(char)* g_get_host_name ();
	const(char)* g_get_prgname ();
	const(char)* g_get_real_name ();
	char** g_get_system_config_dirs ();
	char** g_get_system_data_dirs ();
	const(char)* g_get_tmp_dir ();
	const(char)* g_get_user_cache_dir ();
	const(char)* g_get_user_config_dir ();
	const(char)* g_get_user_data_dir ();
	const(char)* g_get_user_name ();
	const(char)* g_get_user_runtime_dir ();
	const(char)* g_get_user_special_dir (GUserDirectory directory);
	const(char)* g_getenv (const(char)* variable);
	char** g_listenv ();
	void g_nullify_pointer (void** nullifyLocation);
	uint g_parse_debug_string (const(char)* str, GDebugKey* keys, uint nkeys);
	char* g_path_get_basename (const(char)* fileName);
	char* g_path_get_dirname (const(char)* fileName);
	int g_path_is_absolute (const(char)* fileName);
	const(char)* g_path_skip_root (const(char)* fileName);
	void g_qsort_with_data (void* pbase, int totalElems, size_t size, GCompareDataFunc compareFunc, void* userData);
	void g_reload_user_special_dirs_cache ();
	void g_set_application_name (const(char)* applicationName);
	void g_set_prgname (const(char)* prgname);
	int g_setenv (const(char)* variable, const(char)* value, int overwrite);
	uint g_spaced_primes_closest (uint num);
	void g_unsetenv (const(char)* variable);

	// glib.Atomic

	int g_atomic_int_add (int* atomic, int val);
	uint g_atomic_int_and (uint* atomic, uint val);
	int g_atomic_int_compare_and_exchange (int* atomic, int oldval, int newval);
	int g_atomic_int_dec_and_test (int* atomic);
	int g_atomic_int_exchange_and_add (int* atomic, int val);
	int g_atomic_int_get (int* atomic);
	void g_atomic_int_inc (int* atomic);
	uint g_atomic_int_or (uint* atomic, uint val);
	void g_atomic_int_set (int* atomic, int newval);
	uint g_atomic_int_xor (uint* atomic, uint val);
	ptrdiff_t g_atomic_pointer_add (void* atomic, ptrdiff_t val);
	size_t g_atomic_pointer_and (void* atomic, size_t val);
	int g_atomic_pointer_compare_and_exchange (void* atomic, void* oldval, void* newval);
	void* g_atomic_pointer_get (void* atomic);
	size_t g_atomic_pointer_or (void* atomic, size_t val);
	void g_atomic_pointer_set (void* atomic, void* newval);
	size_t g_atomic_pointer_xor (void* atomic, size_t val);

	// glib.CharacterSet

	char* g_convert (const(char)* str, ptrdiff_t len, const(char)* toCodeset, const(char)* fromCodeset, size_t* bytesRead, size_t* bytesWritten, GError** err);
	GQuark g_convert_error_quark ();
	char* g_convert_with_fallback (const(char)* str, ptrdiff_t len, const(char)* toCodeset, const(char)* fromCodeset, const(char)* fallback, size_t* bytesRead, size_t* bytesWritten, GError** err);
	char* g_convert_with_iconv (const(char)* str, ptrdiff_t len, GIConv converter, size_t* bytesRead, size_t* bytesWritten, GError** err);
	char* g_filename_display_basename (const(char)* filename);
	char* g_filename_display_name (const(char)* filename);
	char* g_filename_from_utf8 (const(char)* utf8string, ptrdiff_t len, size_t* bytesRead, size_t* bytesWritten, GError** err);
	char* g_filename_to_utf8 (const(char)* opsysstring, ptrdiff_t len, size_t* bytesRead, size_t* bytesWritten, GError** err);
	int g_get_charset (char** charset);
	char* g_get_codeset ();
	int g_get_filename_charsets (char*** charsets);
	char* g_locale_from_utf8 (const(char)* utf8string, ptrdiff_t len, size_t* bytesRead, size_t* bytesWritten, GError** err);
	char* g_locale_to_utf8 (const(char)* opsysstring, ptrdiff_t len, size_t* bytesRead, size_t* bytesWritten, GError** err);

	// glib.Child

	uint g_child_watch_add (GPid pid, GChildWatchFunc funct, void* data);
	uint g_child_watch_add_full (int priority, GPid pid, GChildWatchFunc funct, void* data, GDestroyNotify notify);
	GSource* g_child_watch_source_new (GPid pid);

	// glib.DataList

	void g_datalist_clear (GData** datalist);
	void g_datalist_foreach (GData** datalist, GDataForeachFunc func, void* userData);
	void* g_datalist_get_data (GData** datalist, const(char)* key);
	uint g_datalist_get_flags (GData** datalist);
	void* g_datalist_id_dup_data (GData** datalist, GQuark keyId, GDuplicateFunc dupFunc, void* userData);
	void* g_datalist_id_get_data (GData** datalist, GQuark keyId);
	void* g_datalist_id_remove_no_notify (GData** datalist, GQuark keyId);
	int g_datalist_id_replace_data (GData** datalist, GQuark keyId, void* oldval, void* newval, GDestroyNotify destroy, GDestroyNotify* oldDestroy);
	void g_datalist_id_set_data_full (GData** datalist, GQuark keyId, void* data, GDestroyNotify destroyFunc);
	void g_datalist_init (GData** datalist);
	void g_datalist_set_flags (GData** datalist, uint flags);
	void g_datalist_unset_flags (GData** datalist, uint flags);

	// glib.DataSet

	void g_dataset_destroy (void* datasetLocation);
	void g_dataset_foreach (void* datasetLocation, GDataForeachFunc func, void* userData);
	void* g_dataset_id_get_data (void* datasetLocation, GQuark keyId);
	void* g_dataset_id_remove_no_notify (void* datasetLocation, GQuark keyId);
	void g_dataset_id_set_data_full (void* datasetLocation, GQuark keyId, void* data, GDestroyNotify destroyFunc);

	// glib.FileUtils

	int g_access (const(char)* filename, int mode);
	int g_chdir (const(char)* path);
	int g_close (int fd, GError** err);
	GFileError g_file_error_from_errno (int errNo);
	GQuark g_file_error_quark ();
	int g_file_get_contents (char* filename, char** contents, size_t* length, GError** err);
	int g_file_open_tmp (char* tmpl, char** nameUsed, GError** err);
	char* g_file_read_link (const(char)* filename, GError** err);
	int g_file_set_contents (char* filename, char* contents, ptrdiff_t length, GError** err);
	int g_file_test (const(char)* filename, GFileTest test);
	int g_mkdir_with_parents (const(char)* pathname, int mode);
	char* g_mkdtemp (char* tmpl);
	char* g_mkdtemp_full (char* tmpl, int mode);
	int g_mkstemp (char* tmpl);
	int g_mkstemp_full (char* tmpl, int flags, int mode);
	int g_rmdir (const(char)* filename);
	int g_unlink (const(char)* filename);

	// glib.Hostname

	int g_hostname_is_ascii_encoded (const(char)* hostname);
	int g_hostname_is_ip_address (const(char)* hostname);
	int g_hostname_is_non_ascii (const(char)* hostname);
	char* g_hostname_to_ascii (const(char)* hostname);
	char* g_hostname_to_unicode (const(char)* hostname);

	// glib.Internationalization

	const(char)* g_dcgettext (const(char)* domain, const(char)* msgid, int category);
	const(char)* g_dgettext (const(char)* domain, const(char)* msgid);
	const(char)* g_dngettext (const(char)* domain, const(char)* msgid, const(char)* msgidPlural, gulong n);
	const(char)* g_dpgettext (const(char)* domain, const(char)* msgctxtid, size_t msgidoffset);
	const(char)* g_dpgettext2 (const(char)* domain, const(char)* context, const(char)* msgid);
	char** g_get_language_names ();
	char** g_get_locale_variants (const(char)* locale);
	const(char)* g_strip_context (const(char)* msgid, const(char)* msgval);

	// glib.Memory

	void g_clear_pointer (void** pp, GDestroyNotify destroy);
	void g_free (void* mem);
	void* g_malloc (size_t nBytes);
	void* g_malloc0 (size_t nBytes);
	void* g_malloc0_n (size_t nBlocks, size_t nBlockBytes);
	void* g_malloc_n (size_t nBlocks, size_t nBlockBytes);
	int g_mem_is_system_malloc ();
	void g_mem_profile ();
	void g_mem_set_vtable (GMemVTable* vtable);
	void* g_memdup (void* mem, uint byteSize);
	void* g_realloc (void* mem, size_t nBytes);
	void* g_realloc_n (void* mem, size_t nBlocks, size_t nBlockBytes);
	void* g_try_malloc (size_t nBytes);
	void* g_try_malloc0 (size_t nBytes);
	void* g_try_malloc0_n (size_t nBlocks, size_t nBlockBytes);
	void* g_try_malloc_n (size_t nBlocks, size_t nBlockBytes);
	void* g_try_realloc (void* mem, size_t nBytes);
	void* g_try_realloc_n (void* mem, size_t nBlocks, size_t nBlockBytes);

	// glib.MessageLog

	void g_log (const(char)* logDomain, GLogLevelFlags logLevel, const(char)* format, ... );
	void g_log_default_handler (const(char)* logDomain, GLogLevelFlags logLevel, const(char)* message, void* unusedData);
	void g_log_remove_handler (const(char)* logDomain, uint handlerId);
	GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatalMask);
	GLogFunc g_log_set_default_handler (GLogFunc logFunc, void* userData);
	GLogLevelFlags g_log_set_fatal_mask (const(char)* logDomain, GLogLevelFlags fatalMask);
	uint g_log_set_handler (const(char)* logDomain, GLogLevelFlags logLevels, GLogFunc logFunc, void* userData);
	uint g_log_set_handler_full (const(char)* logDomain, GLogLevelFlags logLevels, GLogFunc logFunc, void* userData, GDestroyNotify destroy);
	void g_logv (const(char)* logDomain, GLogLevelFlags logLevel, const(char)* format, void* args);

	// glib.Messages

	void g_on_error_query (const(char)* prgName);
	void g_on_error_stack_trace (const(char)* prgName);
	void g_print (const(char)* format, ... );
	void g_printerr (const(char)* format, ... );
	GPrintFunc g_set_print_handler (GPrintFunc func);
	GPrintFunc g_set_printerr_handler (GPrintFunc func);

	// glib.Quark

	const(char)* g_intern_static_string (const(char)* str);
	const(char)* g_intern_string (const(char)* str);
	GQuark g_quark_from_static_string (const(char)* str);
	GQuark g_quark_from_string (const(char)* str);
	const(char)* g_quark_to_string (GQuark quark);
	GQuark g_quark_try_string (const(char)* str);

	// glib.ShellUtils

	GQuark g_shell_error_quark ();
	int g_shell_parse_argv (const(char)* commandLine, int* argcp, char*** argvp, GError** err);
	char* g_shell_quote (const(char)* unquotedString);
	char* g_shell_unquote (const(char)* quotedString, GError** err);

	// glib.Unicode

	wchar* g_ucs4_to_utf16 (dchar* str, glong len, glong* itemsRead, glong* itemsWritten, GError** err);
	char* g_ucs4_to_utf8 (dchar* str, glong len, glong* itemsRead, glong* itemsWritten, GError** err);
	GUnicodeBreakType g_unichar_break_type (dchar c);
	int g_unichar_combining_class (dchar uc);
	int g_unichar_compose (dchar a, dchar b, dchar* ch);
	int g_unichar_decompose (dchar ch, dchar* a, dchar* b);
	int g_unichar_digit_value (dchar c);
	size_t g_unichar_fully_decompose (dchar ch, int compat, dchar* result, size_t resultLen);
	int g_unichar_get_mirror_char (dchar ch, dchar* mirroredCh);
	GUnicodeScript g_unichar_get_script (dchar ch);
	int g_unichar_isalnum (dchar c);
	int g_unichar_isalpha (dchar c);
	int g_unichar_iscntrl (dchar c);
	int g_unichar_isdefined (dchar c);
	int g_unichar_isdigit (dchar c);
	int g_unichar_isgraph (dchar c);
	int g_unichar_islower (dchar c);
	int g_unichar_ismark (dchar c);
	int g_unichar_isprint (dchar c);
	int g_unichar_ispunct (dchar c);
	int g_unichar_isspace (dchar c);
	int g_unichar_istitle (dchar c);
	int g_unichar_isupper (dchar c);
	int g_unichar_iswide (dchar c);
	int g_unichar_iswide_cjk (dchar c);
	int g_unichar_isxdigit (dchar c);
	int g_unichar_iszerowidth (dchar c);
	int g_unichar_to_utf8 (dchar c, char* outbuf);
	dchar g_unichar_tolower (dchar c);
	dchar g_unichar_totitle (dchar c);
	dchar g_unichar_toupper (dchar c);
	GUnicodeType g_unichar_type (dchar c);
	int g_unichar_validate (dchar ch);
	int g_unichar_xdigit_value (dchar c);
	dchar* g_unicode_canonical_decomposition (dchar ch, size_t* resultLen);
	void g_unicode_canonical_ordering (dchar* str, size_t len);
	GUnicodeScript g_unicode_script_from_iso15924 (uint iso15924);
	uint g_unicode_script_to_iso15924 (GUnicodeScript script);
	dchar* g_utf16_to_ucs4 (wchar* str, glong len, glong* itemsRead, glong* itemsWritten, GError** err);
	char* g_utf16_to_utf8 (wchar* str, glong len, glong* itemsRead, glong* itemsWritten, GError** err);
	char* g_utf8_casefold (const(char)* str, ptrdiff_t len);
	int g_utf8_collate (const(char)* str1, const(char)* str2);
	char* g_utf8_collate_key (const(char)* str, ptrdiff_t len);
	char* g_utf8_collate_key_for_filename (const(char)* str, ptrdiff_t len);
	char* g_utf8_find_next_char (const(char)* p, const(char)* end);
	char* g_utf8_find_prev_char (const(char)* str, const(char)* p);
	dchar g_utf8_get_char (const(char)* p);
	dchar g_utf8_get_char_validated (const(char)* p, ptrdiff_t maxLen);
	char* g_utf8_normalize (const(char)* str, ptrdiff_t len, GNormalizeMode mode);
	char* g_utf8_offset_to_pointer (const(char)* str, glong offset);
	glong g_utf8_pointer_to_offset (const(char)* str, const(char)* pos);
	char* g_utf8_prev_char (const(char)* p);
	char* g_utf8_strchr (const(char)* p, ptrdiff_t len, dchar c);
	char* g_utf8_strdown (const(char)* str, ptrdiff_t len);
	glong g_utf8_strlen (const(char)* p, ptrdiff_t max);
	char* g_utf8_strncpy (char* dest, const(char)* src, size_t n);
	char* g_utf8_strrchr (const(char)* p, ptrdiff_t len, dchar c);
	char* g_utf8_strreverse (const(char)* str, ptrdiff_t len);
	char* g_utf8_strup (const(char)* str, ptrdiff_t len);
	char* g_utf8_substring (const(char)* str, glong startPos, glong endPos);
	dchar* g_utf8_to_ucs4 (const(char)* str, glong len, glong* itemsRead, glong* itemsWritten, GError** err);
	dchar* g_utf8_to_ucs4_fast (const(char)* str, glong len, glong* itemsWritten);
	wchar* g_utf8_to_utf16 (const(char)* str, glong len, glong* itemsRead, glong* itemsWritten, GError** err);
	int g_utf8_validate (char* str, ptrdiff_t maxLen, char** end);

	// glib.UnixUtils

	GQuark g_unix_error_quark ();
	uint g_unix_fd_add (int fd, GIOCondition condition, GUnixFDSourceFunc funct, void* userData);
	uint g_unix_fd_add_full (int priority, int fd, GIOCondition condition, GUnixFDSourceFunc funct, void* userData, GDestroyNotify notify);
	GSource* g_unix_fd_source_new (int fd, GIOCondition condition);
	int g_unix_open_pipe (int* fds, int flags, GError** err);
	int g_unix_set_fd_nonblocking (int fd, int nonblock, GError** err);
	uint g_unix_signal_add (int signum, GSourceFunc handler, void* userData);
	uint g_unix_signal_add_full (int priority, int signum, GSourceFunc handler, void* userData, GDestroyNotify notify);
	GSource* g_unix_signal_source_new (int signum);

	// glib.URI

	char* g_filename_from_uri (const(char)* uri, char** hostname, GError** err);
	char* g_filename_to_uri (const(char)* filename, const(char)* hostname, GError** err);
	char* g_uri_escape_string (const(char)* unescaped, const(char)* reservedCharsAllowed, int allowUtf8);
	char** g_uri_list_extract_uris (const(char)* uriList);
	char* g_uri_parse_scheme (const(char)* uri);
	char* g_uri_unescape_segment (const(char)* escapedString, const(char)* escapedStringEnd, const(char)* illegalCharacters);
	char* g_uri_unescape_string (const(char)* escapedString, const(char)* illegalCharacters);

	// glib.Version

	const(char)* glib_check_version (uint requiredMajor, uint requiredMinor, uint requiredMicro);
}

