declare namespace Gsk {
	class BlendMode {
        // 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": BlendMode
		static readonly "kMultiply": BlendMode
		static readonly "kScreen": BlendMode
		static readonly "kOverlay": BlendMode
		static readonly "kDarken": BlendMode
		static readonly "kLighten": BlendMode
		static readonly "kColorDodge": BlendMode
		static readonly "kColorBurn": BlendMode
		static readonly "kHardLight": BlendMode
		static readonly "kSoftLight": BlendMode
		static readonly "kDifference": BlendMode
		static readonly "kExclusion": BlendMode
		static readonly "kColor": BlendMode
		static readonly "kHue": BlendMode
		static readonly "kSaturation": BlendMode
		static readonly "kLuminosity": BlendMode
	}

	class Corner {
        // 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 "kTopLeft": Corner
		static readonly "kTopRight": Corner
		static readonly "kBottomRight": Corner
		static readonly "kBottomLeft": Corner
	}

	class GLUniformType {
        // 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": GLUniformType
		static readonly "kFloat": GLUniformType
		static readonly "kInt": GLUniformType
		static readonly "kUint": GLUniformType
		static readonly "kBool": GLUniformType
		static readonly "kVec2": GLUniformType
		static readonly "kVec3": GLUniformType
		static readonly "kVec4": GLUniformType
	}

	class RenderNodeType {
        // 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 "kNotARenderNode": RenderNodeType
		static readonly "kContainerNode": RenderNodeType
		static readonly "kCairoNode": RenderNodeType
		static readonly "kColorNode": RenderNodeType
		static readonly "kLinearGradientNode": RenderNodeType
		static readonly "kRepeatingLinearGradientNode": RenderNodeType
		static readonly "kRadialGradientNode": RenderNodeType
		static readonly "kRepeatingRadialGradientNode": RenderNodeType
		static readonly "kConicGradientNode": RenderNodeType
		static readonly "kBorderNode": RenderNodeType
		static readonly "kTextureNode": RenderNodeType
		static readonly "kTextureScaleNode": RenderNodeType
		static readonly "kInsetShadowNode": RenderNodeType
		static readonly "kOutsetShadowNode": RenderNodeType
		static readonly "kTransformNode": RenderNodeType
		static readonly "kOpacityNode": RenderNodeType
		static readonly "kColorMatrixNode": RenderNodeType
		static readonly "kRepeatNode": RenderNodeType
		static readonly "kClipNode": RenderNodeType
		static readonly "kRoundedClipNode": RenderNodeType
		static readonly "kShadowNode": RenderNodeType
		static readonly "kBlendNode": RenderNodeType
		static readonly "kMaskNode": RenderNodeType
		static readonly "kCrossFadeNode": RenderNodeType
		static readonly "kTextNode": RenderNodeType
		static readonly "kBlurNode": RenderNodeType
		static readonly "kDebugNode": RenderNodeType
		static readonly "kGlShaderNode": RenderNodeType
	}

	class ScalingFilter {
        // 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 "kLinear": ScalingFilter
		static readonly "kNearest": ScalingFilter
		static readonly "kTrilinear": ScalingFilter
	}

	class SerializationError {
        // 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 "kUnsupportedFormat": SerializationError
		static readonly "kUnsupportedVersion": SerializationError
		static readonly "kInvalidData": SerializationError
	}

	class TransformCategory {
        // 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 "kUnknown": TransformCategory
		static readonly "kAny": TransformCategory
		static readonly "k3d": TransformCategory
		static readonly "k2d": TransformCategory
		static readonly "k2dAffine": TransformCategory
		static readonly "k2dTranslate": TransformCategory
		static readonly "kIdentity": TransformCategory
	}


	class CairoRendererClass {
	}

	class ColorStop {
		offset : number;
		color : AuGDK.RGBA;

	}

	class GLRendererClass {
	}

	class GLShaderClass {
		parentClass : GObject.ObjectClass;

	}

	class ParseLocation {
		bytes : number | bigint;
		chars : number | bigint;
		lines : number | bigint;
		lineBytes : number | bigint;
		lineChars : number | bigint;

	}

	class RendererClass {
	}

	class RoundedRect {
		bounds : Graphene.Rect;
		corner : Graphene.Size[];

		containsPoint(point: Graphene.Point): boolean;
		containsRect(rect: Graphene.Rect): boolean;
		init(bounds: Graphene.Rect, topLeft: Graphene.Size, topRight: Graphene.Size, bottomRight: Graphene.Size, bottomLeft: Graphene.Size): Gsk.RoundedRect;
		initCopy(src: Gsk.RoundedRect): Gsk.RoundedRect;
		initFromRect(bounds: Graphene.Rect, radius: number): Gsk.RoundedRect;
		intersectsRect(rect: Graphene.Rect): boolean;
		isRectilinear(): boolean;
		normalize(): Gsk.RoundedRect;
		offset(dx: number, dy: number): Gsk.RoundedRect;
		shrink(top: number, right: number, bottom: number, left: number): Gsk.RoundedRect;
	}

	class ShaderArgsBuilder {
		static New(shader: Gsk.GLShader, initialValues: AuGlibEx.Bytes | undefined | null): Gsk.ShaderArgsBuilder;
		ref(): Gsk.ShaderArgsBuilder;
		setBool(idx: number, value: boolean): void;
		setFloat(idx: number, value: number): void;
		setInt(idx: number, value: number): void;
		setUint(idx: number, value: number): void;
		setVec2(idx: number, value: Graphene.Vec2): void;
		setVec3(idx: number, value: Graphene.Vec3): void;
		setVec4(idx: number, value: Graphene.Vec4): void;
		toArgs(): AuGlibEx.Bytes;
		unref(): void;
	}

	class Shadow {
		color : AuGDK.RGBA;
		dx : number;
		dy : number;
		radius : number;

	}

	class Transform {
		static New(): Gsk.Transform;
		equal(second: Gsk.Transform | undefined | null): boolean;
		getCategory(): Gsk.TransformCategory;
		invert(): Gsk.Transform;
		matrix(matrix: Graphene.Matrix): Gsk.Transform;
		perspective(depth: number): Gsk.Transform;
		print(string: AuGlibEx.String): void;
		ref(): Gsk.Transform;
		rotate(angle: number): Gsk.Transform;
		rotate3d(angle: number, axis: Graphene.Vec3): Gsk.Transform;
		scale(factorX: number, factorY: number): Gsk.Transform;
		scale3d(factorX: number, factorY: number, factorZ: number): Gsk.Transform;
		skew(skewX: number, skewY: number): Gsk.Transform;
		to2d(outXX: number, outYX: number, outXY: number, outYY: number, outDx: number, outDy: number): void;
		to2dComponents(outSkewX: number, outSkewY: number, outScaleX: number, outScaleY: number, outAngle: number, outDx: number, outDy: number): void;
		toAffine(outScaleX: number, outScaleY: number, outDx: number, outDy: number): void;
		toMatrix(outMatrix: Graphene.Matrix): void;
		toTranslate(outDx: number, outDy: number): void;
		transform(other: Gsk.Transform | undefined | null): Gsk.Transform;
		transformBounds(rect: Graphene.Rect, outRect: Graphene.Rect): void;
		transformPoint(point: Graphene.Point, outPoint: Graphene.Point): void;
		translate(point: Graphene.Point): Gsk.Transform;
		translate3d(point: Graphene.Point3D): Gsk.Transform;
		unref(): void;
		static Parse(string: string, outTransform: Gsk.Transform): boolean;
	}


	class BlendNode extends Gsk.RenderNode {
		constructor(initializerList ?: BlendNodeCtor);

		static New(bottom: Gsk.RenderNode, top: Gsk.RenderNode, blendMode: Gsk.BlendMode): Gsk.BlendNode;
		getBlendMode(): Gsk.BlendMode;
		getBottomChild(): Gsk.RenderNode;
		getTopChild(): Gsk.RenderNode;
		//TypeScript is complete garbage: 
	}

	class BlendNodeCtor {
	}

	class BlurNode extends Gsk.RenderNode {
		constructor(initializerList ?: BlurNodeCtor);

		static New(child: Gsk.RenderNode, radius: number): Gsk.BlurNode;
		getChild(): Gsk.RenderNode;
		getRadius(): number;
		//TypeScript is complete garbage: 
	}

	class BlurNodeCtor {
	}

	class BorderNode extends Gsk.RenderNode {
		constructor(initializerList ?: BorderNodeCtor);

		static New(outline: Gsk.RoundedRect, borderWidth: number[], borderColor: AuGDK.RGBA[]): Gsk.BorderNode;
		getColors(): AuGDK.RGBA;
		getOutline(): Gsk.RoundedRect;
		getWidths(): number[];
		//TypeScript is complete garbage: 
	}

	class BorderNodeCtor {
	}

	class CairoNode extends Gsk.RenderNode {
		constructor(initializerList ?: CairoNodeCtor);

		static New(bounds: Graphene.Rect): Gsk.CairoNode;
		getDrawContext(): cairo.Context;
		getSurface(): cairo.Surface;
		//TypeScript is complete garbage: 
	}

	class CairoNodeCtor {
	}

	class CairoRenderer extends Gsk.Renderer {
		constructor(initializerList ?: CairoRendererCtor);

		static New(): Gsk.Renderer;
		//TypeScript is complete garbage: 
	}

	class CairoRendererCtor {
		realized ?: boolean;
		surface ?: AuGDK.Surface;
	}

	class ClipNode extends Gsk.RenderNode {
		constructor(initializerList ?: ClipNodeCtor);

		static New(child: Gsk.RenderNode, clip: Graphene.Rect): Gsk.ClipNode;
		getChild(): Gsk.RenderNode;
		getClip(): Graphene.Rect;
		//TypeScript is complete garbage: 
	}

	class ClipNodeCtor {
	}

	class ColorMatrixNode extends Gsk.RenderNode {
		constructor(initializerList ?: ColorMatrixNodeCtor);

		static New(child: Gsk.RenderNode, colorMatrix: Graphene.Matrix, colorOffset: Graphene.Vec4): Gsk.ColorMatrixNode;
		getChild(): Gsk.RenderNode;
		getColorMatrix(): Graphene.Matrix;
		getColorOffset(): Graphene.Vec4;
		//TypeScript is complete garbage: 
	}

	class ColorMatrixNodeCtor {
	}

	class ColorNode extends Gsk.RenderNode {
		constructor(initializerList ?: ColorNodeCtor);

		static New(rgba: AuGDK.RGBA, bounds: Graphene.Rect): Gsk.ColorNode;
		getColor(): AuGDK.RGBA;
		//TypeScript is complete garbage: 
	}

	class ColorNodeCtor {
	}

	class ConicGradientNode extends Gsk.RenderNode {
		constructor(initializerList ?: ConicGradientNodeCtor);

		static New(bounds: Graphene.Rect, center: Graphene.Point, rotation: number, colorStops: Gsk.ColorStop[], nColorStops: number | bigint): Gsk.ConicGradientNode;
		getAngle(): number;
		getCenter(): Graphene.Point;
		getColorStops(nStops ?: number | bigint): Gsk.ColorStop[];
		getNColorStops(): number | bigint;
		getRotation(): number;
		//TypeScript is complete garbage: 
	}

	class ConicGradientNodeCtor {
	}

	class ContainerNode extends Gsk.RenderNode {
		constructor(initializerList ?: ContainerNodeCtor);

		static New(children: Gsk.RenderNode[], nChildren: number): Gsk.ContainerNode;
		getChild(idx: number): Gsk.RenderNode;
		getNChildren(): number;
		//TypeScript is complete garbage: 
	}

	class ContainerNodeCtor {
	}

	class CrossFadeNode extends Gsk.RenderNode {
		constructor(initializerList ?: CrossFadeNodeCtor);

		static New(start: Gsk.RenderNode, end: Gsk.RenderNode, progress: number): Gsk.CrossFadeNode;
		getEndChild(): Gsk.RenderNode;
		getProgress(): number;
		getStartChild(): Gsk.RenderNode;
		//TypeScript is complete garbage: 
	}

	class CrossFadeNodeCtor {
	}

	class DebugNode extends Gsk.RenderNode {
		constructor(initializerList ?: DebugNodeCtor);

		static New(child: Gsk.RenderNode, message: string): Gsk.DebugNode;
		getChild(): Gsk.RenderNode;
		getMessage(): string;
		//TypeScript is complete garbage: 
	}

	class DebugNodeCtor {
	}

	class GLRenderer extends Gsk.Renderer {
		constructor(initializerList ?: GLRendererCtor);

		static New(): Gsk.Renderer;
		//TypeScript is complete garbage: 
	}

	class GLRendererCtor {
		realized ?: boolean;
		surface ?: AuGDK.Surface;
	}

	class GLShader extends GObject.Object {
		constructor(initializerList ?: GLShaderCtor);

		resource : string;
		source : AuGlibEx.Bytes;

		static NewFromBytes(sourcecode: AuGlibEx.Bytes): Gsk.GLShader;
		static NewFromResource(resourcePath: string): Gsk.GLShader;
		compile(renderer: Gsk.Renderer): boolean;
		findUniformByName(name: string): number;
		getArgBool(args: AuGlibEx.Bytes, idx: number): boolean;
		getArgFloat(args: AuGlibEx.Bytes, idx: number): number;
		getArgInt(args: AuGlibEx.Bytes, idx: number): number;
		getArgUint(args: AuGlibEx.Bytes, idx: number): number;
		getArgVec2(args: AuGlibEx.Bytes, idx: number, outValue: Graphene.Vec2): void;
		getArgVec3(args: AuGlibEx.Bytes, idx: number, outValue: Graphene.Vec3): void;
		getArgVec4(args: AuGlibEx.Bytes, idx: number, outValue: Graphene.Vec4): void;
		getArgsSize(): number | bigint;
		getNTextures(): number;
		getNUniforms(): number;
		getResource(): string;
		getSource(): AuGlibEx.Bytes;
		getUniformName(idx: number): string;
		getUniformOffset(idx: number): number;
		getUniformType(idx: number): Gsk.GLUniformType;
		//TypeScript is complete garbage: 
	}

	class GLShaderCtor {
		source ?: AuGlibEx.Bytes;
		resource ?: string;
	}

	class GLShaderNode extends Gsk.RenderNode {
		constructor(initializerList ?: GLShaderNodeCtor);

		static New(shader: Gsk.GLShader, bounds: Graphene.Rect, args: AuGlibEx.Bytes, children: Gsk.RenderNode[] | undefined | null, nChildren: number): Gsk.GLShaderNode;
		getArgs(): AuGlibEx.Bytes;
		getChild(idx: number): Gsk.RenderNode;
		getNChildren(): number;
		getShader(): Gsk.GLShader;
		//TypeScript is complete garbage: 
	}

	class GLShaderNodeCtor {
	}

	class InsetShadowNode extends Gsk.RenderNode {
		constructor(initializerList ?: InsetShadowNodeCtor);

		static New(outline: Gsk.RoundedRect, color: AuGDK.RGBA, dx: number, dy: number, spread: number, blurRadius: number): Gsk.InsetShadowNode;
		getBlurRadius(): number;
		getColor(): AuGDK.RGBA;
		getDx(): number;
		getDy(): number;
		getOutline(): Gsk.RoundedRect;
		getSpread(): number;
		//TypeScript is complete garbage: 
	}

	class InsetShadowNodeCtor {
	}

	class LinearGradientNode extends Gsk.RenderNode {
		constructor(initializerList ?: LinearGradientNodeCtor);

		static New(bounds: Graphene.Rect, start: Graphene.Point, end: Graphene.Point, colorStops: Gsk.ColorStop[], nColorStops: number | bigint): Gsk.LinearGradientNode;
		getColorStops(nStops ?: number | bigint): Gsk.ColorStop[];
		getEnd(): Graphene.Point;
		getNColorStops(): number | bigint;
		getStart(): Graphene.Point;
		//TypeScript is complete garbage: 
	}

	class LinearGradientNodeCtor {
	}

	class MaskNode extends Gsk.RenderNode {
		constructor(initializerList ?: MaskNodeCtor);

		static New(source: Gsk.RenderNode, mask: Gsk.RenderNode): Gsk.MaskNode;
		static GetMask(node: Gsk.BlendNode): Gsk.RenderNode;
		static GetSource(node: Gsk.BlendNode): Gsk.RenderNode;
		//TypeScript is complete garbage: 
	}

	class MaskNodeCtor {
	}

	class NglRenderer extends Gsk.Renderer {
		constructor(initializerList ?: NglRendererCtor);

		static New(): Gsk.Renderer;
		//TypeScript is complete garbage: 
	}

	class NglRendererCtor {
		realized ?: boolean;
		surface ?: AuGDK.Surface;
	}

	class OpacityNode extends Gsk.RenderNode {
		constructor(initializerList ?: OpacityNodeCtor);

		static New(child: Gsk.RenderNode, opacity: number): Gsk.OpacityNode;
		getChild(): Gsk.RenderNode;
		getOpacity(): number;
		//TypeScript is complete garbage: 
	}

	class OpacityNodeCtor {
	}

	class OutsetShadowNode extends Gsk.RenderNode {
		constructor(initializerList ?: OutsetShadowNodeCtor);

		static New(outline: Gsk.RoundedRect, color: AuGDK.RGBA, dx: number, dy: number, spread: number, blurRadius: number): Gsk.OutsetShadowNode;
		getBlurRadius(): number;
		getColor(): AuGDK.RGBA;
		getDx(): number;
		getDy(): number;
		getOutline(): Gsk.RoundedRect;
		getSpread(): number;
		//TypeScript is complete garbage: 
	}

	class OutsetShadowNodeCtor {
	}

	class RadialGradientNode extends Gsk.RenderNode {
		constructor(initializerList ?: RadialGradientNodeCtor);

		static New(bounds: Graphene.Rect, center: Graphene.Point, hradius: number, vradius: number, start: number, end: number, colorStops: Gsk.ColorStop[], nColorStops: number | bigint): Gsk.RadialGradientNode;
		getCenter(): Graphene.Point;
		getColorStops(nStops ?: number | bigint): Gsk.ColorStop[];
		getEnd(): number;
		getHradius(): number;
		getNColorStops(): number | bigint;
		getStart(): number;
		getVradius(): number;
		//TypeScript is complete garbage: 
	}

	class RadialGradientNodeCtor {
	}

	class RenderNode {
		constructor(initializerList ?: RenderNodeCtor);

		static Deserialize(bytes: AuGlibEx.Bytes, errorFunc: (start: Gsk.ParseLocation, end: Gsk.ParseLocation, error: AuGlibEx.Error) => void | undefined | null): Gsk.RenderNode;
		draw(cr: cairo.Context): void;
		getBounds(bounds: Graphene.Rect): void;
		getNodeType(): Gsk.RenderNodeType;
		ref(): Gsk.RenderNode;
		serialize(): AuGlibEx.Bytes;
		unref(): void;
		writeToFile(filename: string): boolean;
		//TypeScript is complete garbage: 
	}

	class RenderNodeCtor {
	}

	class Renderer extends GObject.Object {
		constructor(initializerList ?: RendererCtor);

		realized : boolean;
		surface : AuGDK.Surface;

		static NewForSurface(surface: AuGDK.Surface): Gsk.Renderer;
		getSurface(): AuGDK.Surface;
		isRealized(): boolean;
		realize(surface: AuGDK.Surface | undefined | null): boolean;
		render(root: Gsk.RenderNode, region: cairo.Region | undefined | null): void;
		renderTexture(root: Gsk.RenderNode, viewport: Graphene.Rect | undefined | null): AuGDK.Texture;
		unrealize(): void;
		//TypeScript is complete garbage: 
	}

	class RendererCtor {
		realized ?: boolean;
		surface ?: AuGDK.Surface;
	}

	class RepeatNode extends Gsk.RenderNode {
		constructor(initializerList ?: RepeatNodeCtor);

		static New(bounds: Graphene.Rect, child: Gsk.RenderNode, childBounds: Graphene.Rect | undefined | null): Gsk.RepeatNode;
		getChild(): Gsk.RenderNode;
		getChildBounds(): Graphene.Rect;
		//TypeScript is complete garbage: 
	}

	class RepeatNodeCtor {
	}

	class RepeatingLinearGradientNode extends Gsk.RenderNode {
		constructor(initializerList ?: RepeatingLinearGradientNodeCtor);

		static New(bounds: Graphene.Rect, start: Graphene.Point, end: Graphene.Point, colorStops: Gsk.ColorStop[], nColorStops: number | bigint): Gsk.RepeatingLinearGradientNode;
		//TypeScript is complete garbage: 
	}

	class RepeatingLinearGradientNodeCtor {
	}

	class RepeatingRadialGradientNode extends Gsk.RenderNode {
		constructor(initializerList ?: RepeatingRadialGradientNodeCtor);

		static New(bounds: Graphene.Rect, center: Graphene.Point, hradius: number, vradius: number, start: number, end: number, colorStops: Gsk.ColorStop[], nColorStops: number | bigint): Gsk.RepeatingRadialGradientNode;
		//TypeScript is complete garbage: 
	}

	class RepeatingRadialGradientNodeCtor {
	}

	class RoundedClipNode extends Gsk.RenderNode {
		constructor(initializerList ?: RoundedClipNodeCtor);

		static New(child: Gsk.RenderNode, clip: Gsk.RoundedRect): Gsk.RoundedClipNode;
		getChild(): Gsk.RenderNode;
		getClip(): Gsk.RoundedRect;
		//TypeScript is complete garbage: 
	}

	class RoundedClipNodeCtor {
	}

	class ShadowNode extends Gsk.RenderNode {
		constructor(initializerList ?: ShadowNodeCtor);

		static New(child: Gsk.RenderNode, shadows: Gsk.Shadow[], nShadows: number | bigint): Gsk.ShadowNode;
		getChild(): Gsk.RenderNode;
		getNShadows(): number | bigint;
		getShadow(i: number | bigint): Gsk.Shadow;
		//TypeScript is complete garbage: 
	}

	class ShadowNodeCtor {
	}

	class TextNode extends Gsk.RenderNode {
		constructor(initializerList ?: TextNodeCtor);

		static New(font: AuPango.Font, glyphs: AuPango.GlyphString, color: AuGDK.RGBA, offset: Graphene.Point): Gsk.TextNode;
		getColor(): AuGDK.RGBA;
		getFont(): AuPango.Font;
		getGlyphs(nGlyphs ?: number): AuPango.GlyphInfo[];
		getNumGlyphs(): number;
		getOffset(): Graphene.Point;
		hasColorGlyphs(): boolean;
		//TypeScript is complete garbage: 
	}

	class TextNodeCtor {
	}

	class TextureNode extends Gsk.RenderNode {
		constructor(initializerList ?: TextureNodeCtor);

		static New(texture: AuGDK.Texture, bounds: Graphene.Rect): Gsk.TextureNode;
		getTexture(): AuGDK.Texture;
		//TypeScript is complete garbage: 
	}

	class TextureNodeCtor {
	}

	class TextureScaleNode extends Gsk.RenderNode {
		constructor(initializerList ?: TextureScaleNodeCtor);

		static New(texture: AuGDK.Texture, bounds: Graphene.Rect, filter: Gsk.ScalingFilter): Gsk.TextureScaleNode;
		static GetFilter(node: Gsk.TextureNode): Gsk.ScalingFilter;
		static GetTexture(node: Gsk.TextureNode): AuGDK.Texture;
		//TypeScript is complete garbage: 
	}

	class TextureScaleNodeCtor {
	}

	class TransformNode extends Gsk.RenderNode {
		constructor(initializerList ?: TransformNodeCtor);

		static New(child: Gsk.RenderNode, transform: Gsk.Transform): Gsk.TransformNode;
		getChild(): Gsk.RenderNode;
		getTransform(): Gsk.Transform;
		//TypeScript is complete garbage: 
	}

	class TransformNodeCtor {
	}
}