declare namespace GObject {

	class BindingFlags {
        // Enumerations hack...
		toString(radix ? : number | undefined) : string;
		toFixed(fractionDigits ? : number | undefined) : string;
		toExponential(fractionDigits ? : number | undefined) : string;
		toPrecision(precision ? : number | undefined) : string;
		valueOf() : number;
		toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;

		static [s:number]: string;

		static readonly "kDefault": BindingFlags
		static readonly "kBidirectional": BindingFlags
		static readonly "kSyncCreate": BindingFlags
		static readonly "kInvertBoolean": BindingFlags
	}

	class ConnectFlags {
        // Enumerations hack...
		toString(radix ? : number | undefined) : string;
		toFixed(fractionDigits ? : number | undefined) : string;
		toExponential(fractionDigits ? : number | undefined) : string;
		toPrecision(precision ? : number | undefined) : string;
		valueOf() : number;
		toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;

		static [s:number]: string;

		static readonly "kAfter": ConnectFlags
		static readonly "kSwapped": ConnectFlags
	}

	class ParamFlags {
        // Enumerations hack...
		toString(radix ? : number | undefined) : string;
		toFixed(fractionDigits ? : number | undefined) : string;
		toExponential(fractionDigits ? : number | undefined) : string;
		toPrecision(precision ? : number | undefined) : string;
		valueOf() : number;
		toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;

		static [s:number]: string;

		static readonly "kReadable": ParamFlags
		static readonly "kWritable": ParamFlags
		static readonly "kReadwrite": ParamFlags
		static readonly "kConstruct": ParamFlags
		static readonly "kConstructOnly": ParamFlags
		static readonly "kLaxValidation": ParamFlags
		static readonly "kStaticName": ParamFlags
		static readonly "kPrivate": ParamFlags
		static readonly "kStaticNick": ParamFlags
		static readonly "kStaticBlurb": ParamFlags
		static readonly "kExplicitNotify": ParamFlags
		static readonly "kDeprecated": ParamFlags
	}

	class SignalFlags {
        // Enumerations hack...
		toString(radix ? : number | undefined) : string;
		toFixed(fractionDigits ? : number | undefined) : string;
		toExponential(fractionDigits ? : number | undefined) : string;
		toPrecision(precision ? : number | undefined) : string;
		valueOf() : number;
		toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;

		static [s:number]: string;

		static readonly "kRunFirst": SignalFlags
		static readonly "kRunLast": SignalFlags
		static readonly "kRunCleanup": SignalFlags
		static readonly "kNoRecurse": SignalFlags
		static readonly "kDetailed": SignalFlags
		static readonly "kAction": SignalFlags
		static readonly "kNoHooks": SignalFlags
		static readonly "kMustCollect": SignalFlags
		static readonly "kDeprecated": SignalFlags
		static readonly "kAccumulatorFirstRun": SignalFlags
	}

	class SignalMatchType {
        // Enumerations hack...
		toString(radix ? : number | undefined) : string;
		toFixed(fractionDigits ? : number | undefined) : string;
		toExponential(fractionDigits ? : number | undefined) : string;
		toPrecision(precision ? : number | undefined) : string;
		valueOf() : number;
		toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;

		static [s:number]: string;

		static readonly "kId": SignalMatchType
		static readonly "kDetail": SignalMatchType
		static readonly "kClosure": SignalMatchType
		static readonly "kFunc": SignalMatchType
		static readonly "kData": SignalMatchType
		static readonly "kUnblocked": SignalMatchType
	}

	class TypeDebugFlags {
        // Enumerations hack...
		toString(radix ? : number | undefined) : string;
		toFixed(fractionDigits ? : number | undefined) : string;
		toExponential(fractionDigits ? : number | undefined) : string;
		toPrecision(precision ? : number | undefined) : string;
		valueOf() : number;
		toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;

		static [s:number]: string;

		static readonly "kNone": TypeDebugFlags
		static readonly "kObjects": TypeDebugFlags
		static readonly "kSignals": TypeDebugFlags
		static readonly "kInstanceCount": TypeDebugFlags
		static readonly "kMask": TypeDebugFlags
	}

	class TypeFlags {
        // Enumerations hack...
		toString(radix ? : number | undefined) : string;
		toFixed(fractionDigits ? : number | undefined) : string;
		toExponential(fractionDigits ? : number | undefined) : string;
		toPrecision(precision ? : number | undefined) : string;
		valueOf() : number;
		toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;

		static [s:number]: string;

		static readonly "kAbstract": TypeFlags
		static readonly "kValueAbstract": TypeFlags
		static readonly "kFinal": TypeFlags
	}

	class TypeFundamentalFlags {
        // Enumerations hack...
		toString(radix ? : number | undefined) : string;
		toFixed(fractionDigits ? : number | undefined) : string;
		toExponential(fractionDigits ? : number | undefined) : string;
		toPrecision(precision ? : number | undefined) : string;
		valueOf() : number;
		toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;

		static [s:number]: string;

		static readonly "kClassed": TypeFundamentalFlags
		static readonly "kInstantiatable": TypeFundamentalFlags
		static readonly "kDerivable": TypeFundamentalFlags
		static readonly "kDeepDerivable": TypeFundamentalFlags
	}


	class TypePlugin {
		completeInterfaceInfo(instanceType: number, interfaceType: number, info: GObject.InterfaceInfo): void;
		completeTypeInfo(gType: number, info: GObject.TypeInfo, valueTable: GObject.TypeValueTable): void;
		unuse(): void;
		use(): void;
	}


	class CClosure {
		closure : GObject.Closure;
		callback : void;

		static MarshalBOOLEANBOXEDBOXED(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalBOOLEANFLAGS(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalSTRINGOBJECTPOINTER(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDBOOLEAN(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDBOXED(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDCHAR(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDDOUBLE(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDENUM(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDFLAGS(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDFLOAT(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDINT(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDLONG(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDOBJECT(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDPARAM(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDPOINTER(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDSTRING(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDUCHAR(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDUINT(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDUINTPOINTER(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDULONG(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDVARIANT(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalVOIDVOID(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
		static MarshalGeneric(closure: GObject.Closure, returnGvalue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
	}

	class Closure {
		refCount : number;
		metaMarshalNouse : number;
		nGuards : number;
		nFnotifiers : number;
		nInotifiers : number;
		inInotify : number;
		floating : number;
		derivativeFlag : number;
		inMarshal : number;
		isInvalid : number;
		marshal : (closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value) => void;
		data : void;
		notifiers : GObject.ClosureNotifyData;

		static NewObject(sizeofClosure: number, object: GObject.Object): GObject.Closure;
		static NewSimple(sizeofClosure: number): GObject.Closure;
		invalidate(): void;
		invoke(returnValue ?: GObject.Value, nParamValues ?: number, paramValues ?: GObject.Value[]): void;
		ref(): GObject.Closure;
		sink(): void;
		unref(): void;
	}

	class ClosureNotifyData {
		data : void;
		notify : (closure: GObject.Closure) => void;

	}

	class EnumClass {
		gTypeClass : GObject.TypeClass;
		minimum : number;
		maximum : number;
		nValues : number;
		values : GObject.EnumValue;

	}

	class EnumValue {
		value : number;
		valueName : string;
		valueNick : string;

	}

	class FlagsClass {
		gTypeClass : GObject.TypeClass;
		mask : number;
		nValues : number;
		values : GObject.FlagsValue;

	}

	class FlagsValue {
		value : number;
		valueName : string;
		valueNick : string;

	}

	class InitiallyUnownedClass { /*unsupported*/ }

	class InterfaceInfo {
		interfaceInit : (gIface: GObject.TypeInterface) => void;
		interfaceFinalize : (gIface: GObject.TypeInterface) => void;
		interfaceData : void;

	}

	class ObjectClass {
		gTypeClass : GObject.TypeClass;
		_constructor : void;
		setProperty : (object: GObject.Object, propertyId: number, value: GObject.Value, pspec: GObject.ParamSpec) => void;
		getProperty : (object: GObject.Object, propertyId: number, value: GObject.Value, pspec: GObject.ParamSpec) => void;
		dispose : (object: GObject.Object) => void;
		finalize : (object: GObject.Object) => void;
		dispatchPropertiesChanged : (object: GObject.Object, nPspecs: number, pspecs: GObject.ParamSpec) => void;
		notify : (object: GObject.Object, pspec: GObject.ParamSpec) => void;
		constructed : (object: GObject.Object) => void;
		flags : number | bigint;

		findProperty(propertyName: string): GObject.ParamSpec;
		installProperties(nPspecs: number, pspecs: GObject.ParamSpec[]): void;
		installProperty(propertyId: number, pspec: GObject.ParamSpec): void;
		listProperties(nProperties: number): GObject.ParamSpec[];
		overrideProperty(propertyId: number, name: string): void;
	}

	class ObjectConstructParam {
		pspec : GObject.ParamSpec;
		value : GObject.Value;

	}

	class ParamSpecClass {
		gTypeClass : GObject.TypeClass;
		valueType : number;
		finalize : (pspec: GObject.ParamSpec) => void;
		valueSetDefault : (pspec: GObject.ParamSpec, value: GObject.Value) => void;
		valueValidate : (pspec: GObject.ParamSpec, value: GObject.Value) => boolean;
		valuesCmp : (pspec: GObject.ParamSpec, value1: GObject.Value, value2: GObject.Value) => number;

	}

	class ParamSpecPool {
		insert(pspec: GObject.ParamSpec, ownerType: number): void;
		list(ownerType: number, nPspecsP: number): GObject.ParamSpec[];
		listOwned(ownerType: number): GObject.ParamSpec[];
		lookup(paramName: string, ownerType: number, walkAncestors: boolean): GObject.ParamSpec;
		remove(pspec: GObject.ParamSpec): void;
	}

	class ParamSpecTypeInfo {
		instanceSize : number;
		nPreallocs : number;
		instanceInit : (pspec: GObject.ParamSpec) => void;
		valueType : number;
		finalize : (pspec: GObject.ParamSpec) => void;
		valueSetDefault : (pspec: GObject.ParamSpec, value: GObject.Value) => void;
		valueValidate : (pspec: GObject.ParamSpec, value: GObject.Value) => boolean;
		valuesCmp : (pspec: GObject.ParamSpec, value1: GObject.Value, value2: GObject.Value) => number;

	}

	class Parameter {
		name : string;
		value : GObject.Value;

	}

	class SignalInvocationHint {
		signalId : number;
		detail : number;
		runType : GObject.SignalFlags;

	}

	class SignalQuery {
		signalId : number;
		signalName : string;
		itype : number;
		signalFlags : GObject.SignalFlags;
		returnType : number;
		nParams : number;
		paramTypes : number[];

	}

	class TypeClass {
		gType : number;

		addPrivate(privateSize: number | bigint): void;
		getPrivate(privateType: number): void;
		peekParent(): GObject.TypeClass;
		unref(): void;
		static AdjustPrivateOffset(privateSizeOrOffset: number): void;
		static Peek(type: number): GObject.TypeClass;
		static PeekStatic(type: number): GObject.TypeClass;
		static Ref(type: number): GObject.TypeClass;
	}

	class TypeFundamentalInfo {
		typeFlags : GObject.TypeFundamentalFlags;

	}

	class TypeInfo {
		classSize : number;
		baseInit : (gClass: GObject.TypeClass) => void;
		baseFinalize : (gClass: GObject.TypeClass) => void;
		classInit : (gClass: GObject.TypeClass) => void;
		classFinalize : (gClass: GObject.TypeClass) => void;
		classData : void;
		instanceSize : number;
		nPreallocs : number;
		instanceInit : (instance: GObject.TypeInstance, gClass: GObject.TypeClass) => void;
		valueTable : GObject.TypeValueTable;

	}

	class TypeInstance {
		gClass : GObject.TypeClass;

		getPrivate(privateType: number): void;
	}

	class TypeInterface {
		gType : number;
		gInstanceType : number;

		peekParent(): GObject.TypeInterface;
		static AddPrerequisite(interfaceType: number, prerequisiteType: number): void;
		static GetPlugin(instanceType: number, interfaceType: number): GObject.TypePlugin;
		static InstantiatablePrerequisite(interfaceType: number): number;
		static Peek(instanceClass: GObject.TypeClass, ifaceType: number): GObject.TypeInterface;
		static Prerequisites(interfaceType: number, nPrerequisites ?: number): number[];
	}

	class TypeModuleClass {
		parentClass : GObject.ObjectClass;
		load : (module: GObject.TypeModule) => boolean;
		unload : (module: GObject.TypeModule) => void;
		reserved1 : () => void;
		reserved2 : () => void;
		reserved3 : () => void;
		reserved4 : () => void;

	}

	class TypePluginClass {
		baseIface : GObject.TypeInterface;
		usePlugin : (plugin: GObject.TypePlugin) => void;
		unusePlugin : (plugin: GObject.TypePlugin) => void;
		completeTypeInfo : (plugin: GObject.TypePlugin, gType: number, info: GObject.TypeInfo, valueTable: GObject.TypeValueTable) => void;
		completeInterfaceInfo : (plugin: GObject.TypePlugin, instanceType: number, interfaceType: number, info: GObject.InterfaceInfo) => void;

	}

	class TypeQuery {
		type : number;
		typeName : string;
		classSize : number;
		instanceSize : number;

	}

	class TypeValueTable { /*unsupported*/ }

	class Value {
		gType : number;

		copy(destValue: GObject.Value): void;
		dupObject(): GObject.Object;
		dupString(): string;
		dupVariant(): AuGlibEx.Variant;
		fitsPointer(): boolean;
		getBoolean(): boolean;
		getBoxed(): void;
		getChar(): number;
		getDouble(): number;
		getEnum(): number;
		getFlags(): number;
		getFloat(): number;
		getGtype(): number;
		getInt(): number;
		getInt64(): number | bigint;
		getLong(): number;
		getObject(): GObject.Object;
		getParam(): GObject.ParamSpec;
		getPointer(): void;
		getSchar(): number;
		getString(): string;
		getUchar(): number;
		getUint(): number;
		getUint64(): number | bigint;
		getUlong(): number;
		getVariant(): AuGlibEx.Variant;
		init(gType: number): GObject.Value;
		initFromInstance(instance: GObject.TypeInstance): void;
		peekPointer(): void;
		reset(): GObject.Value;
		setBoolean(vBoolean: boolean): void;
		setBoxed(): void;
		setBoxedTakeOwnership(): void;
		setChar(vChar: number): void;
		setDouble(vDouble: number): void;
		setEnum(vEnum: number): void;
		setFlags(vFlags: number): void;
		setFloat(vFloat: number): void;
		setGtype(vGtype: number): void;
		setInstance(): void;
		setInt(vInt: number): void;
		setInt64(vInt64: number | bigint): void;
		setInternedString(vString: string | undefined | null): void;
		setLong(vLong: number): void;
		setObject(vObject: GObject.Object | undefined | null): void;
		setParam(param: GObject.ParamSpec | undefined | null): void;
		setPointer(): void;
		setSchar(vChar: number): void;
		setStaticBoxed(): void;
		setStaticString(vString: string | undefined | null): void;
		setString(vString: string | undefined | null): void;
		setStringTakeOwnership(vString: string | undefined | null): void;
		setUchar(vUchar: number): void;
		setUint(vUint: number): void;
		setUint64(vUint64: number | bigint): void;
		setUlong(vUlong: number): void;
		setVariant(variant: AuGlibEx.Variant | undefined | null): void;
		takeBoxed(): void;
		takeString(vString: string | undefined | null): void;
		takeVariant(variant: AuGlibEx.Variant | undefined | null): void;
		transform(destValue: GObject.Value): boolean;
		unset(): void;
		static TypeCompatible(srcType: number, destType: number): boolean;
		static TypeTransformable(srcType: number, destType: number): boolean;
	}

	class ValueArray {
		nValues : number;
		values : GObject.Value;
		nPrealloced : number;

		static New(nPrealloced: number): GObject.ValueArray;
		append(value: GObject.Value | undefined | null): GObject.ValueArray;
		copy(): GObject.ValueArray;
		getNth(index: number): GObject.Value;
		insert(index: number, value: GObject.Value | undefined | null): GObject.ValueArray;
		prepend(value: GObject.Value | undefined | null): GObject.ValueArray;
		remove(index: number): GObject.ValueArray;
		sort(compareFunc: () => number): GObject.ValueArray;
	}

	class WeakRef {
	}


	class Binding extends GObject.Object {
		constructor(initializerList ?: BindingCtor);

		flags : GObject.BindingFlags;
		source : GObject.Object;
		sourceProperty : string;
		target : GObject.Object;
		targetProperty : string;

		dupSource(): GObject.Object;
		dupTarget(): GObject.Object;
		getFlags(): GObject.BindingFlags;
		getSource(): GObject.Object;
		getSourceProperty(): string;
		getTarget(): GObject.Object;
		getTargetProperty(): string;
		unbind(): void;
		//TypeScript is complete garbage: 
	}

	class BindingCtor {
		source ?: GObject.Object;
		target ?: GObject.Object;
		sourceProperty ?: string;
		targetProperty ?: string;
		flags ?: GObject.BindingFlags;
	}

	class BindingGroup extends GObject.Object {
		constructor(initializerList ?: BindingGroupCtor);

		source : GObject.Object;

		static New(): GObject.BindingGroup;
		bind(sourceProperty: string, target: GObject.Object, targetProperty: string, flags: GObject.BindingFlags): void;
		bindFull(sourceProperty: string, target: GObject.Object, targetProperty: string, flags: GObject.BindingFlags, transformTo: GObject.Closure | undefined | null, transformFrom: GObject.Closure | undefined | null): void;
		dupSource(): GObject.Object;
		setSource(source: GObject.Object | undefined | null): void;
		//TypeScript is complete garbage: 
	}

	class BindingGroupCtor {
		source ?: GObject.Object;
	}

	class InitiallyUnowned extends GObject.Object {
		constructor(initializerList ?: InitiallyUnownedCtor);

		gTypeInstance : GObject.TypeInstance;
		refCount : number;
		qdata : AuGlibEx.Data;

		//TypeScript is complete garbage: 
	}

	class InitiallyUnownedCtor {
	}

	class Object {
		constructor(initializerList ?: ObjectCtor);

		gTypeInstance : GObject.TypeInstance;
		refCount : number;
		qdata : AuGlibEx.Data;

		static Newv(objectType: number, nParameters: number, parameters: GObject.Parameter[]): GObject.Object;
		static CompatControl(what: number | bigint): number | bigint;
		static InterfaceFindProperty(gIface: GObject.TypeInterface, propertyName: string): GObject.ParamSpec;
		static InterfaceInstallProperty(gIface: GObject.TypeInterface, pspec: GObject.ParamSpec): void;
		static InterfaceListProperties(gIface: GObject.TypeInterface, nPropertiesP: number): GObject.ParamSpec[];
		bindProperty(sourceProperty: string, target: GObject.Object, targetProperty: string, flags: GObject.BindingFlags): GObject.Binding;
		bindPropertyFull(sourceProperty: string, target: GObject.Object, targetProperty: string, flags: GObject.BindingFlags, transformTo: GObject.Closure, transformFrom: GObject.Closure): GObject.Binding;
		forceFloating(): void;
		freezeNotify(): void;
		getData(key: string): void;
		getProperty(propertyName: string, value: GObject.Value): void;
		getQdata(quark: number): void;
		getv(nProperties: number, names: string[], values: GObject.Value[]): void;
		isFloating(): boolean;
		notify(propertyName: string): void;
		notifyByPspec(pspec: GObject.ParamSpec): void;
		ref(): GObject.Object;
		refSink(): GObject.Object;
		runDispose(): void;
		setData(key: string): void;
		setProperty(propertyName: string, value: GObject.Value): void;
		stealData(key: string): void;
		stealQdata(quark: number): void;
		thawNotify(): void;
		unref(): void;
		watchClosure(closure: GObject.Closure): void;
		attachEventListener(listener: AuGlibEx.IEventListener): AuGlibEx.EventListener;

		//TypeScript is complete garbage: 
	}

	class ObjectCtor {
	}

	class ObjectEventListener extends AuGlibEx.IEventListener {
		notify(pspec: GObject.ParamSpec): void;
	}

	class ParamSpec {
		constructor(initializerList ?: ParamSpecCtor);

		gTypeInstance : GObject.TypeInstance;
		name : string;
		flags : GObject.ParamFlags;
		valueType : number;
		ownerType : number;
		nick : string;
		blurb : string;
		qdata : AuGlibEx.Data;
		refCount : number;
		paramId : number;

		static IsValidName(name: string): boolean;
		getBlurb(): string;
		getDefaultValue(): GObject.Value;
		getName(): string;
		getNameQuark(): number;
		getNick(): string;
		getQdata(quark: number): void;
		getRedirectTarget(): GObject.ParamSpec;
		setQdata(quark: number): void;
		sink(): void;
		stealQdata(quark: number): void;
		//TypeScript is complete garbage: 
	}

	class ParamSpecCtor {
	}

	class ParamSpecBoolean extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecBooleanCtor);

		parentInstance : GObject.ParamSpec;
		defaultValue : boolean;

		//TypeScript is complete garbage: 
	}

	class ParamSpecBooleanCtor {
	}

	class ParamSpecBoxed extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecBoxedCtor);

		parentInstance : GObject.ParamSpec;

		//TypeScript is complete garbage: 
	}

	class ParamSpecBoxedCtor {
	}

	class ParamSpecChar extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecCharCtor);

		parentInstance : GObject.ParamSpec;
		minimum : number;
		maximum : number;
		defaultValue : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecCharCtor {
	}

	class ParamSpecDouble extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecDoubleCtor);

		parentInstance : GObject.ParamSpec;
		minimum : number;
		maximum : number;
		defaultValue : number;
		epsilon : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecDoubleCtor {
	}

	class ParamSpecEnum extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecEnumCtor);

		parentInstance : GObject.ParamSpec;
		enumClass : GObject.EnumClass;
		defaultValue : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecEnumCtor {
	}

	class ParamSpecFlags extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecFlagsCtor);

		parentInstance : GObject.ParamSpec;
		flagsClass : GObject.FlagsClass;
		defaultValue : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecFlagsCtor {
	}

	class ParamSpecFloat extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecFloatCtor);

		parentInstance : GObject.ParamSpec;
		minimum : number;
		maximum : number;
		defaultValue : number;
		epsilon : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecFloatCtor {
	}

	class ParamSpecGType extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecGTypeCtor);

		parentInstance : GObject.ParamSpec;
		isAType : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecGTypeCtor {
	}

	class ParamSpecInt extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecIntCtor);

		parentInstance : GObject.ParamSpec;
		minimum : number;
		maximum : number;
		defaultValue : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecIntCtor {
	}

	class ParamSpecInt64 extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecInt64Ctor);

		parentInstance : GObject.ParamSpec;
		minimum : number | bigint;
		maximum : number | bigint;
		defaultValue : number | bigint;

		//TypeScript is complete garbage: 
	}

	class ParamSpecInt64Ctor {
	}

	class ParamSpecLong extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecLongCtor);

		parentInstance : GObject.ParamSpec;
		minimum : number;
		maximum : number;
		defaultValue : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecLongCtor {
	}

	class ParamSpecObject extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecObjectCtor);

		parentInstance : GObject.ParamSpec;

		//TypeScript is complete garbage: 
	}

	class ParamSpecObjectCtor {
	}

	class ParamSpecOverride extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecOverrideCtor);

		parentInstance : GObject.ParamSpec;
		overridden : GObject.ParamSpec;

		//TypeScript is complete garbage: 
	}

	class ParamSpecOverrideCtor {
	}

	class ParamSpecParam extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecParamCtor);

		parentInstance : GObject.ParamSpec;

		//TypeScript is complete garbage: 
	}

	class ParamSpecParamCtor {
	}

	class ParamSpecPointer extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecPointerCtor);

		parentInstance : GObject.ParamSpec;

		//TypeScript is complete garbage: 
	}

	class ParamSpecPointerCtor {
	}

	class ParamSpecString extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecStringCtor);

		parentInstance : GObject.ParamSpec;
		defaultValue : string;
		csetFirst : string;
		csetNth : string;
		substitutor : number;
		nullFoldIfEmpty : number;
		ensureNonNull : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecStringCtor {
	}

	class ParamSpecUChar extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecUCharCtor);

		parentInstance : GObject.ParamSpec;
		minimum : number;
		maximum : number;
		defaultValue : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecUCharCtor {
	}

	class ParamSpecUInt extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecUIntCtor);

		parentInstance : GObject.ParamSpec;
		minimum : number;
		maximum : number;
		defaultValue : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecUIntCtor {
	}

	class ParamSpecUInt64 extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecUInt64Ctor);

		parentInstance : GObject.ParamSpec;
		minimum : number | bigint;
		maximum : number | bigint;
		defaultValue : number | bigint;

		//TypeScript is complete garbage: 
	}

	class ParamSpecUInt64Ctor {
	}

	class ParamSpecULong extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecULongCtor);

		parentInstance : GObject.ParamSpec;
		minimum : number;
		maximum : number;
		defaultValue : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecULongCtor {
	}

	class ParamSpecUnichar extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecUnicharCtor);

		parentInstance : GObject.ParamSpec;
		defaultValue : string;

		//TypeScript is complete garbage: 
	}

	class ParamSpecUnicharCtor {
	}

	class ParamSpecValueArray extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecValueArrayCtor);

		parentInstance : GObject.ParamSpec;
		elementSpec : GObject.ParamSpec;
		fixedNElements : number;

		//TypeScript is complete garbage: 
	}

	class ParamSpecValueArrayCtor {
	}

	class ParamSpecVariant extends GObject.ParamSpec {
		constructor(initializerList ?: ParamSpecVariantCtor);

		parentInstance : GObject.ParamSpec;
		type : AuGlibEx.VariantType;
		defaultValue : AuGlibEx.Variant;

		//TypeScript is complete garbage: 
	}

	class ParamSpecVariantCtor {
	}

	class SignalGroup extends GObject.Object {
		constructor(initializerList ?: SignalGroupCtor);

		target : GObject.Object;
		targetType : number;

		static New(targetType: number): GObject.SignalGroup;
		block(): void;
		connectData(detailedSignal: string, cHandler: () => void, notify: (closure: GObject.Closure) => void, flags: GObject.ConnectFlags): void;
		connectSwapped(detailedSignal: string, cHandler: () => void): void;
		dupTarget(): GObject.Object;
		setTarget(target: GObject.Object | undefined | null): void;
		unblock(): void;
		//TypeScript is complete garbage: 
	}

	class SignalGroupCtor {
		target ?: GObject.Object;
		targetType ?: any;
	}

	class SignalGroupEventListener extends AuGlibEx.IEventListener {
		bind(instance: GObject.Object): void;
		unbind(): void;
	}

	class TypeModule extends GObject.Object implements GObject.TypePlugin {
		constructor(initializerList ?: TypeModuleCtor);

		parentInstance : GObject.Object;
		useCount : number;
		name : string;

		addInterface(instanceType: number, interfaceType: number, interfaceInfo: GObject.InterfaceInfo): void;
		registerEnum(name: string, constStaticValues: GObject.EnumValue): number;
		registerFlags(name: string, constStaticValues: GObject.FlagsValue): number;
		registerType(parentType: number, typeName: string, typeInfo: GObject.TypeInfo, flags: GObject.TypeFlags): number;
		setName(name: string): void;
		unuse(): void;
		use(): boolean;
		//TypeScript is complete garbage: 
		completeInterfaceInfo(instanceType: number, interfaceType: number, info: GObject.InterfaceInfo): void;
		completeTypeInfo(gType: number, info: GObject.TypeInfo, valueTable: GObject.TypeValueTable): void;
	}

	class TypeModuleCtor {
	}
}