declare namespace GstBase {

	class AggregatorStartTimeSelection {
        // 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 "kZero": AggregatorStartTimeSelection
		static readonly "kFirst": AggregatorStartTimeSelection
		static readonly "kSet": AggregatorStartTimeSelection
	}

	class BaseParseFrameFlags {
        // 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": BaseParseFrameFlags
		static readonly "kNewFrame": BaseParseFrameFlags
		static readonly "kNoFrame": BaseParseFrameFlags
		static readonly "kClip": BaseParseFrameFlags
		static readonly "kDrop": BaseParseFrameFlags
		static readonly "kQueue": BaseParseFrameFlags
	}

	class BaseSrcFlags {
        // 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 "kStarting": BaseSrcFlags
		static readonly "kStarted": BaseSrcFlags
		static readonly "kLast": BaseSrcFlags
	}

	class CollectPadsStateFlags {
        // 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 "kEos": CollectPadsStateFlags
		static readonly "kFlushing": CollectPadsStateFlags
		static readonly "kNewSegment": CollectPadsStateFlags
		static readonly "kWaiting": CollectPadsStateFlags
		static readonly "kLocked": CollectPadsStateFlags
	}


	class AdapterClass {
	}

	class AggregatorClass {
		parentClass : Gst.ElementClass;
		flush : (aggregator: GstBase.Aggregator) => Gst.FlowReturn;
		clip : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, buf: Gst.Buffer) => Gst.Buffer;
		finishBuffer : (aggregator: GstBase.Aggregator, buffer: Gst.Buffer) => Gst.FlowReturn;
		sinkEvent : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, event: Gst.Event) => boolean;
		sinkQuery : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, query: Gst.Query) => boolean;
		srcEvent : (aggregator: GstBase.Aggregator, event: Gst.Event) => boolean;
		srcQuery : (aggregator: GstBase.Aggregator, query: Gst.Query) => boolean;
		srcActivate : (aggregator: GstBase.Aggregator, mode: Gst.PadMode, active: boolean) => boolean;
		aggregate : (aggregator: GstBase.Aggregator, timeout: boolean) => Gst.FlowReturn;
		stop : (aggregator: GstBase.Aggregator) => boolean;
		start : (aggregator: GstBase.Aggregator) => boolean;
		getNextTime : (aggregator: GstBase.Aggregator) => number | bigint;
		createNewPad : void;
		updateSrcCaps : (self: GstBase.Aggregator, caps: Gst.Caps, ret ?: Gst.Caps) => Gst.FlowReturn;
		fixateSrcCaps : (self: GstBase.Aggregator, caps: Gst.Caps) => Gst.Caps;
		negotiatedSrcCaps : (self: GstBase.Aggregator, caps: Gst.Caps) => boolean;
		decideAllocation : (self: GstBase.Aggregator, query: Gst.Query) => boolean;
		proposeAllocation : (self: GstBase.Aggregator, pad: GstBase.AggregatorPad, decideQuery: Gst.Query, query: Gst.Query) => boolean;
		negotiate : (self: GstBase.Aggregator) => boolean;
		sinkEventPreQueue : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, event: Gst.Event) => Gst.FlowReturn;
		sinkQueryPreQueue : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, query: Gst.Query) => boolean;
		finishBufferList : (aggregator: GstBase.Aggregator, bufferlist: Gst.BufferList) => Gst.FlowReturn;
		peekNextSample : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad) => Gst.Sample;

	}

	class AggregatorPadClass {
		parentClass : Gst.PadClass;
		flush : (aggpad: GstBase.AggregatorPad, aggregator: GstBase.Aggregator) => Gst.FlowReturn;
		skipBuffer : (aggpad: GstBase.AggregatorPad, aggregator: GstBase.Aggregator, buffer: Gst.Buffer) => boolean;

	}

	class AggregatorPadPrivate {
	}

	class AggregatorPrivate {
	}

	class BaseParseClass {
		parentClass : Gst.ElementClass;
		start : (parse: GstBase.BaseParse) => boolean;
		stop : (parse: GstBase.BaseParse) => boolean;
		setSinkCaps : (parse: GstBase.BaseParse, caps: Gst.Caps) => boolean;
		handleFrame : (parse: GstBase.BaseParse, frame: GstBase.BaseParseFrame, skipsize: number) => Gst.FlowReturn;
		prePushFrame : (parse: GstBase.BaseParse, frame: GstBase.BaseParseFrame) => Gst.FlowReturn;
		convert : (parse: GstBase.BaseParse, srcFormat: Gst.Format, srcValue: number | bigint, destFormat: Gst.Format, destValue: number | bigint) => boolean;
		sinkEvent : (parse: GstBase.BaseParse, event: Gst.Event) => boolean;
		srcEvent : (parse: GstBase.BaseParse, event: Gst.Event) => boolean;
		getSinkCaps : (parse: GstBase.BaseParse, filter: Gst.Caps) => Gst.Caps;
		detect : (parse: GstBase.BaseParse, buffer: Gst.Buffer) => Gst.FlowReturn;
		sinkQuery : (parse: GstBase.BaseParse, query: Gst.Query) => boolean;
		srcQuery : (parse: GstBase.BaseParse, query: Gst.Query) => boolean;

	}

	class BaseParseFrame {
		buffer : Gst.Buffer;
		outBuffer : Gst.Buffer;
		flags : number;
		offset : number | bigint;
		overhead : number;
		size : number;
		gstReservedI : number[];
		privateFlags : number;

		static New(buffer: Gst.Buffer, flags: GstBase.BaseParseFrameFlags, overhead: number): GstBase.BaseParseFrame;
		copy(): GstBase.BaseParseFrame;
		free(): void;
		init(): void;
	}

	class BaseParsePrivate {
	}

	class BaseSinkClass {
		parentClass : Gst.ElementClass;
		getCaps : (sink: GstBase.BaseSink, filter: Gst.Caps) => Gst.Caps;
		setCaps : (sink: GstBase.BaseSink, caps: Gst.Caps) => boolean;
		fixate : (sink: GstBase.BaseSink, caps: Gst.Caps) => Gst.Caps;
		activatePull : (sink: GstBase.BaseSink, active: boolean) => boolean;
		getTimes : (sink: GstBase.BaseSink, buffer: Gst.Buffer, start: number | bigint, end: number | bigint) => void;
		proposeAllocation : (sink: GstBase.BaseSink, query: Gst.Query) => boolean;
		start : (sink: GstBase.BaseSink) => boolean;
		stop : (sink: GstBase.BaseSink) => boolean;
		unlock : (sink: GstBase.BaseSink) => boolean;
		unlockStop : (sink: GstBase.BaseSink) => boolean;
		query : (sink: GstBase.BaseSink, query: Gst.Query) => boolean;
		event : (sink: GstBase.BaseSink, event: Gst.Event) => boolean;
		waitEvent : (sink: GstBase.BaseSink, event: Gst.Event) => Gst.FlowReturn;
		prepare : (sink: GstBase.BaseSink, buffer: Gst.Buffer) => Gst.FlowReturn;
		prepareList : (sink: GstBase.BaseSink, bufferList: Gst.BufferList) => Gst.FlowReturn;
		preroll : (sink: GstBase.BaseSink, buffer: Gst.Buffer) => Gst.FlowReturn;
		render : (sink: GstBase.BaseSink, buffer: Gst.Buffer) => Gst.FlowReturn;
		renderList : (sink: GstBase.BaseSink, bufferList: Gst.BufferList) => Gst.FlowReturn;

	}

	class BaseSinkPrivate {
	}

	class BaseSrcClass {
		parentClass : Gst.ElementClass;
		getCaps : (src: GstBase.BaseSrc, filter: Gst.Caps | undefined | null) => Gst.Caps;
		negotiate : (src: GstBase.BaseSrc) => boolean;
		fixate : (src: GstBase.BaseSrc, caps: Gst.Caps) => Gst.Caps;
		setCaps : (src: GstBase.BaseSrc, caps: Gst.Caps) => boolean;
		decideAllocation : (src: GstBase.BaseSrc, query: Gst.Query) => boolean;
		start : (src: GstBase.BaseSrc) => boolean;
		stop : (src: GstBase.BaseSrc) => boolean;
		getTimes : (src: GstBase.BaseSrc, buffer: Gst.Buffer, start: number | bigint, end: number | bigint) => void;
		getSize : (src: GstBase.BaseSrc, size: number | bigint) => boolean;
		isSeekable : (src: GstBase.BaseSrc) => boolean;
		prepareSeekSegment : (src: GstBase.BaseSrc, seek: Gst.Event, segment: Gst.Segment) => boolean;
		doSeek : (src: GstBase.BaseSrc, segment: Gst.Segment) => boolean;
		unlock : (src: GstBase.BaseSrc) => boolean;
		unlockStop : (src: GstBase.BaseSrc) => boolean;
		query : (src: GstBase.BaseSrc, query: Gst.Query) => boolean;
		event : (src: GstBase.BaseSrc, event: Gst.Event) => boolean;
		create : (src: GstBase.BaseSrc, offset: number | bigint, size: number, buf: Gst.Buffer) => Gst.FlowReturn;
		alloc : (src: GstBase.BaseSrc, offset: number | bigint, size: number, buf: Gst.Buffer) => Gst.FlowReturn;
		fill : (src: GstBase.BaseSrc, offset: number | bigint, size: number, buf: Gst.Buffer) => Gst.FlowReturn;

	}

	class BaseSrcPrivate {
	}

	class BaseTransformClass {
		parentClass : Gst.ElementClass;
		passthroughOnSameCaps : boolean;
		transformIpOnPassthrough : boolean;
		transformCaps : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, caps: Gst.Caps, filter: Gst.Caps) => Gst.Caps;
		fixateCaps : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, caps: Gst.Caps, othercaps: Gst.Caps) => Gst.Caps;
		acceptCaps : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, caps: Gst.Caps) => boolean;
		setCaps : (trans: GstBase.BaseTransform, incaps: Gst.Caps, outcaps: Gst.Caps) => boolean;
		query : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, query: Gst.Query) => boolean;
		decideAllocation : (trans: GstBase.BaseTransform, query: Gst.Query) => boolean;
		filterMeta : (trans: GstBase.BaseTransform, query: Gst.Query, api: number, params: Gst.Structure) => boolean;
		proposeAllocation : (trans: GstBase.BaseTransform, decideQuery: Gst.Query, query: Gst.Query) => boolean;
		transformSize : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, caps: Gst.Caps, size: number | bigint, othercaps: Gst.Caps, othersize: number | bigint) => boolean;
		getUnitSize : (trans: GstBase.BaseTransform, caps: Gst.Caps, size: number | bigint) => boolean;
		start : (trans: GstBase.BaseTransform) => boolean;
		stop : (trans: GstBase.BaseTransform) => boolean;
		sinkEvent : (trans: GstBase.BaseTransform, event: Gst.Event) => boolean;
		srcEvent : (trans: GstBase.BaseTransform, event: Gst.Event) => boolean;
		prepareOutputBuffer : (trans: GstBase.BaseTransform, input: Gst.Buffer, outbuf: Gst.Buffer) => Gst.FlowReturn;
		copyMetadata : (trans: GstBase.BaseTransform, input: Gst.Buffer, outbuf: Gst.Buffer) => boolean;
		transformMeta : (trans: GstBase.BaseTransform, outbuf: Gst.Buffer, meta: Gst.Meta, inbuf: Gst.Buffer) => boolean;
		beforeTransform : (trans: GstBase.BaseTransform, buffer: Gst.Buffer) => void;
		transform : (trans: GstBase.BaseTransform, inbuf: Gst.Buffer, outbuf: Gst.Buffer) => Gst.FlowReturn;
		transformIp : (trans: GstBase.BaseTransform, buf: Gst.Buffer) => Gst.FlowReturn;
		submitInputBuffer : (trans: GstBase.BaseTransform, isDiscont: boolean, input: Gst.Buffer) => Gst.FlowReturn;
		generateOutput : (trans: GstBase.BaseTransform, outbuf: Gst.Buffer) => Gst.FlowReturn;

	}

	class BaseTransformPrivate {
	}

	class BitReader {
		data : number[];
		size : number;
		byte : number;
		bit : number;

		free(): void;
		getBitsUint16(val: number, nbits: number): boolean;
		getBitsUint32(val: number, nbits: number): boolean;
		getBitsUint64(val: number | bigint, nbits: number): boolean;
		getBitsUint8(val: number, nbits: number): boolean;
		getPos(): number;
		getRemaining(): number;
		getSize(): number;
		init(data: number[], size: number): void;
		peekBitsUint16(val: number, nbits: number): boolean;
		peekBitsUint32(val: number, nbits: number): boolean;
		peekBitsUint64(val: number | bigint, nbits: number): boolean;
		peekBitsUint8(val: number, nbits: number): boolean;
		setPos(pos: number): boolean;
		skip(nbits: number): boolean;
		skipToByte(): boolean;
	}

	class BitWriter {
		data : number;
		bitSize : number;
		bitCapacity : number;
		autoGrow : boolean;
		owned : boolean;

		alignBytes(trailingBit: number): boolean;
		free(): void;
		freeAndGetBuffer(): Gst.Buffer;
		freeAndGetData(): number[];
		getData(): number[];
		getRemaining(): number;
		getSize(): number;
		putBitsUint16(value: number, nbits: number): boolean;
		putBitsUint32(value: number, nbits: number): boolean;
		putBitsUint64(value: number | bigint, nbits: number): boolean;
		putBitsUint8(value: number, nbits: number): boolean;
		putBytes(data: number[], nbytes: number): boolean;
		reset(): void;
		resetAndGetBuffer(): Gst.Buffer;
		resetAndGetData(): number[];
		setPos(pos: number): boolean;
	}

	class ByteReader {
		data : number[];
		size : number;
		byte : number;

		dupData(size: number, val: number[]): boolean;
		dupStringUtf16(str: number[]): boolean;
		dupStringUtf32(str: number[]): boolean;
		dupStringUtf8(str: string[]): boolean;
		free(): void;
		getData(size: number, val: number[]): boolean;
		getFloat32Be(val: number): boolean;
		getFloat32Le(val: number): boolean;
		getFloat64Be(val: number): boolean;
		getFloat64Le(val: number): boolean;
		getInt16Be(val: number): boolean;
		getInt16Le(val: number): boolean;
		getInt24Be(val: number): boolean;
		getInt24Le(val: number): boolean;
		getInt32Be(val: number): boolean;
		getInt32Le(val: number): boolean;
		getInt64Be(val: number | bigint): boolean;
		getInt64Le(val: number | bigint): boolean;
		getInt8(val: number): boolean;
		getPos(): number;
		getRemaining(): number;
		getSize(): number;
		getStringUtf8(str: string[]): boolean;
		getUint16Be(val: number): boolean;
		getUint16Le(val: number): boolean;
		getUint24Be(val: number): boolean;
		getUint24Le(val: number): boolean;
		getUint32Be(val: number): boolean;
		getUint32Le(val: number): boolean;
		getUint64Be(val: number | bigint): boolean;
		getUint64Le(val: number | bigint): boolean;
		getUint8(val: number): boolean;
		init(data: number[], size: number): void;
		maskedScanUint32(mask: number, pattern: number, offset: number, size: number): number;
		maskedScanUint32Peek(mask: number, pattern: number, offset: number, size: number, value: number): number;
		peekData(size: number, val: number[]): boolean;
		peekFloat32Be(val: number): boolean;
		peekFloat32Le(val: number): boolean;
		peekFloat64Be(val: number): boolean;
		peekFloat64Le(val: number): boolean;
		peekInt16Be(val: number): boolean;
		peekInt16Le(val: number): boolean;
		peekInt24Be(val: number): boolean;
		peekInt24Le(val: number): boolean;
		peekInt32Be(val: number): boolean;
		peekInt32Le(val: number): boolean;
		peekInt64Be(val: number | bigint): boolean;
		peekInt64Le(val: number | bigint): boolean;
		peekInt8(val: number): boolean;
		peekStringUtf8(str: string[]): boolean;
		peekUint16Be(val: number): boolean;
		peekUint16Le(val: number): boolean;
		peekUint24Be(val: number): boolean;
		peekUint24Le(val: number): boolean;
		peekUint32Be(val: number): boolean;
		peekUint32Le(val: number): boolean;
		peekUint64Be(val: number | bigint): boolean;
		peekUint64Le(val: number | bigint): boolean;
		peekUint8(val: number): boolean;
		setPos(pos: number): boolean;
		skip(nbytes: number): boolean;
		skipStringUtf16(): boolean;
		skipStringUtf32(): boolean;
		skipStringUtf8(): boolean;
	}

	class ByteWriter {
		parent : GstBase.ByteReader;
		allocSize : number;
		fixed : boolean;
		owned : boolean;

		ensureFreeSpace(size: number): boolean;
		fill(value: number, size: number): boolean;
		free(): void;
		freeAndGetBuffer(): Gst.Buffer;
		freeAndGetData(): number;
		getRemaining(): number;
		init(): void;
		initWithData(data: number[], size: number, initialized: boolean): void;
		initWithSize(size: number, fixed: boolean): void;
		putBuffer(buffer: Gst.Buffer, offset: number | bigint, size: number | bigint): boolean;
		putData(data: number[], size: number): boolean;
		putFloat32Be(val: number): boolean;
		putFloat32Le(val: number): boolean;
		putFloat64Be(val: number): boolean;
		putFloat64Le(val: number): boolean;
		putInt16Be(val: number): boolean;
		putInt16Le(val: number): boolean;
		putInt24Be(val: number): boolean;
		putInt24Le(val: number): boolean;
		putInt32Be(val: number): boolean;
		putInt32Le(val: number): boolean;
		putInt64Be(val: number | bigint): boolean;
		putInt64Le(val: number | bigint): boolean;
		putInt8(val: number): boolean;
		putStringUtf16(data: number[]): boolean;
		putStringUtf32(data: number[]): boolean;
		putStringUtf8(data: string): boolean;
		putUint16Be(val: number): boolean;
		putUint16Le(val: number): boolean;
		putUint24Be(val: number): boolean;
		putUint24Le(val: number): boolean;
		putUint32Be(val: number): boolean;
		putUint32Le(val: number): boolean;
		putUint64Be(val: number | bigint): boolean;
		putUint64Le(val: number | bigint): boolean;
		putUint8(val: number): boolean;
		reset(): void;
		resetAndGetBuffer(): Gst.Buffer;
		resetAndGetData(): number[];
	}

	class CollectData {
		collect : GstBase.CollectPads;
		pad : Gst.Pad;
		buffer : Gst.Buffer;
		pos : number;
		segment : Gst.Segment;
		state : GstBase.CollectPadsStateFlags;
		priv : GstBase.CollectDataPrivate;

	}

	class CollectDataPrivate {
	}

	class CollectPadsClass {
		parentClass : Gst.ObjectClass;

	}

	class CollectPadsPrivate {
	}

	class DataQueueClass {
		parentClass : GObject.ObjectClass;
		empty : (queue: GstBase.DataQueue) => void;
		full : (queue: GstBase.DataQueue) => void;

	}

	class DataQueuePrivate {
	}

	class FlowCombiner {
		static New(): GstBase.FlowCombiner;
		addPad(pad: Gst.Pad): void;
		clear(): void;
		free(): void;
		ref(): GstBase.FlowCombiner;
		removePad(pad: Gst.Pad): void;
		reset(): void;
		unref(): void;
		updateFlow(fret: Gst.FlowReturn): Gst.FlowReturn;
		updatePadFlow(pad: Gst.Pad, fret: Gst.FlowReturn): Gst.FlowReturn;
	}

	class PushSrcClass {
		parentClass : GstBase.BaseSrcClass;
		create : (src: GstBase.PushSrc, buf: Gst.Buffer) => Gst.FlowReturn;
		alloc : (src: GstBase.PushSrc, buf: Gst.Buffer) => Gst.FlowReturn;
		fill : (src: GstBase.PushSrc, buf: Gst.Buffer) => Gst.FlowReturn;

	}


	class Adapter extends GObject.Object {
		constructor(initializerList ?: AdapterCtor);

		static New(): GstBase.Adapter;
		available(): number | bigint;
		availableFast(): number | bigint;
		clear(): void;
		copy(offset: number | bigint, size: number | bigint): AuGlibEx.Bytes;
		distanceFromDiscont(): number | bigint;
		dtsAtDiscont(): number | bigint;
		flush(flush: number | bigint): void;
		getBuffer(nbytes: number | bigint): Gst.Buffer;
		getBufferFast(nbytes: number | bigint): Gst.Buffer;
		getBufferList(nbytes: number | bigint): Gst.BufferList;
		getList(nbytes: number | bigint): Gst.Buffer[];
		map(size: number | bigint): number[];
		maskedScanUint32(mask: number, pattern: number, offset: number | bigint, size: number | bigint): number | bigint;
		maskedScanUint32Peek(mask: number, pattern: number, offset: number | bigint, size: number | bigint, value ?: number): number | bigint;
		offsetAtDiscont(): number | bigint;
		prevDts(distance ?: number | bigint): number | bigint;
		prevDtsAtOffset(offset: number | bigint, distance ?: number | bigint): number | bigint;
		prevOffset(distance ?: number | bigint): number | bigint;
		prevPts(distance ?: number | bigint): number | bigint;
		prevPtsAtOffset(offset: number | bigint, distance ?: number | bigint): number | bigint;
		ptsAtDiscont(): number | bigint;
		push(buf: Gst.Buffer): void;
		take(nbytes: number | bigint): number[];
		takeBuffer(nbytes: number | bigint): Gst.Buffer;
		takeBufferFast(nbytes: number | bigint): Gst.Buffer;
		takeBufferList(nbytes: number | bigint): Gst.BufferList;
		takeList(nbytes: number | bigint): Gst.Buffer[];
		unmap(): void;
		//TypeScript is complete garbage: 
	}

	class AdapterCtor {
	}

	class Aggregator extends Gst.Element {
		constructor(initializerList ?: AggregatorCtor);

		parent : Gst.Element;
		srcpad : Gst.Pad;
		priv : GstBase.AggregatorPrivate;

		emitSignals : boolean;
		latency : number | bigint;
		minUpstreamLatency : number | bigint;
		startTime : number | bigint;
		startTimeSelection : GstBase.AggregatorStartTimeSelection;

		finishBuffer(buffer: Gst.Buffer): Gst.FlowReturn;
		finishBufferList(bufferlist: Gst.BufferList): Gst.FlowReturn;
		getAllocator(allocator ?: Gst.Allocator | undefined | null, params ?: Gst.AllocationParams): void;
		getBufferPool(): Gst.BufferPool;
		getIgnoreInactivePads(): boolean;
		getLatency(): number | bigint;
		negotiate(): boolean;
		peekNextSample(pad: GstBase.AggregatorPad): Gst.Sample;
		selectedSamples(pts: number | bigint, dts: number | bigint, duration: number | bigint, info: Gst.Structure | undefined | null): void;
		setIgnoreInactivePads(ignore: boolean): void;
		setLatency(minLatency: number | bigint, maxLatency: number | bigint): void;
		setSrcCaps(caps: Gst.Caps): void;
		simpleGetNextTime(): number | bigint;
		updateSegment(segment: Gst.Segment): void;
		//TypeScript is complete garbage: 
	}

	class AggregatorCtor {
		name ?: string;
		parent ?: Gst.Object;
		latency ?: number;
		minUpstreamLatency ?: number;
		startTimeSelection ?: GstBase.AggregatorStartTimeSelection;
		startTime ?: number;
		emitSignals ?: boolean;
	}

	class AggregatorEventListener extends AuGlibEx.IEventListener {
		samplesSelected(segment: Gst.Segment, pts: number | bigint, dts: number | bigint, duration: number | bigint, info: Gst.Structure | undefined | null): void;
	}

	class AggregatorPad extends Gst.Pad {
		constructor(initializerList ?: AggregatorPadCtor);

		parent : Gst.Pad;
		segment : Gst.Segment;
		priv : GstBase.AggregatorPadPrivate;

		emitSignals : boolean;

		dropBuffer(): boolean;
		hasBuffer(): boolean;
		isEos(): boolean;
		isInactive(): boolean;
		peekBuffer(): Gst.Buffer;
		popBuffer(): Gst.Buffer;
		//TypeScript is complete garbage: 
	}

	class AggregatorPadCtor {
		name ?: string;
		parent ?: Gst.Object;
		direction ?: Gst.PadDirection;
		template ?: Gst.PadTemplate;
		offset ?: number | bigint;
		emitSignals ?: boolean;
	}

	class AggregatorPadEventListener extends AuGlibEx.IEventListener {
		bufferConsumed(object: Gst.Buffer): void;
	}

	class BaseParse extends Gst.Element {
		constructor(initializerList ?: BaseParseCtor);

		element : Gst.Element;
		sinkpad : Gst.Pad;
		srcpad : Gst.Pad;
		flags : number;
		segment : Gst.Segment;
		priv : GstBase.BaseParsePrivate;

		disablePassthrough : boolean;

		addIndexEntry(offset: number | bigint, ts: number | bigint, key: boolean, force: boolean): boolean;
		convertDefault(srcFormat: Gst.Format, srcValue: number | bigint, destFormat: Gst.Format, destValue: number | bigint): boolean;
		drain(): void;
		finishFrame(frame: GstBase.BaseParseFrame, size: number): Gst.FlowReturn;
		mergeTags(tags: Gst.TagList | undefined | null, mode: Gst.TagMergeMode): void;
		pushFrame(frame: GstBase.BaseParseFrame): Gst.FlowReturn;
		setAverageBitrate(bitrate: number): void;
		setDuration(fmt: Gst.Format, duration: number | bigint, interval: number): void;
		setFrameRate(fpsNum: number, fpsDen: number, leadIn: number, leadOut: number): void;
		setHasTimingInfo(hasTiming: boolean): void;
		setInferTs(inferTs: boolean): void;
		setLatency(minLatency: number | bigint, maxLatency: number | bigint): void;
		setMinFrameSize(minSize: number): void;
		setPassthrough(passthrough: boolean): void;
		setPtsInterpolation(ptsInterpolate: boolean): void;
		setSyncable(syncable: boolean): void;
		setTsAtOffset(offset: number | bigint): void;
		//TypeScript is complete garbage: 
	}

	class BaseParseCtor {
		name ?: string;
		parent ?: Gst.Object;
		disablePassthrough ?: boolean;
	}

	class BaseSink extends Gst.Element {
		constructor(initializerList ?: BaseSinkCtor);

		element : Gst.Element;
		sinkpad : Gst.Pad;
		padMode : Gst.PadMode;
		offset : number | bigint;
		canActivatePull : boolean;
		canActivatePush : boolean;
		prerollCond : AuGlibEx.Cond;
		eos : boolean;
		needPreroll : boolean;
		havePreroll : boolean;
		playingAsync : boolean;
		haveNewsegment : boolean;
		segment : Gst.Segment;
		clockId : void;
		sync : boolean;
		flushing : boolean;
		running : boolean;
		maxLateness : number | bigint;
		priv : GstBase.BaseSinkPrivate;

		_async : boolean;
		blocksize : number;
		enableLastSample : boolean;
		lastSample : Gst.Sample;
		maxBitrate : number | bigint;
		processingDeadline : number | bigint;
		qos : boolean;
		renderDelay : number | bigint;
		stats : Gst.Structure;
		throttleTime : number | bigint;
		tsOffset : number | bigint;

		doPreroll(obj: Gst.MiniObject): Gst.FlowReturn;
		getBlocksize(): number;
		getDropOutOfSegment(): boolean;
		getLastSample(): Gst.Sample;
		getLatency(): number | bigint;
		getMaxBitrate(): number | bigint;
		getMaxLateness(): number | bigint;
		getProcessingDeadline(): number | bigint;
		getRenderDelay(): number | bigint;
		getStats(): Gst.Structure;
		getSync(): boolean;
		getThrottleTime(): number | bigint;
		getTsOffset(): number | bigint;
		isAsyncEnabled(): boolean;
		isLastSampleEnabled(): boolean;
		isQosEnabled(): boolean;
		queryLatency(live ?: boolean, upstreamLive ?: boolean, minLatency ?: number | bigint, maxLatency ?: number | bigint): boolean;
		setAsyncEnabled(enabled: boolean): void;
		setBlocksize(blocksize: number): void;
		setDropOutOfSegment(dropOutOfSegment: boolean): void;
		setLastSampleEnabled(enabled: boolean): void;
		setMaxBitrate(maxBitrate: number | bigint): void;
		setMaxLateness(maxLateness: number | bigint): void;
		setProcessingDeadline(processingDeadline: number | bigint): void;
		setQosEnabled(enabled: boolean): void;
		setRenderDelay(delay: number | bigint): void;
		setSync(sync: boolean): void;
		setThrottleTime(throttle: number | bigint): void;
		setTsOffset(offset: number | bigint): void;
		wait(time: number | bigint, jitter ?: number | bigint): Gst.FlowReturn;
		waitClock(time: number | bigint, jitter ?: number | bigint): Gst.ClockReturn;
		waitPreroll(): Gst.FlowReturn;
		//TypeScript is complete garbage: 
	}

	class BaseSinkCtor {
		name ?: string;
		parent ?: Gst.Object;
		sync ?: boolean;
		maxLateness ?: number | bigint;
		qos ?: boolean;
		async ?: boolean;
		tsOffset ?: number | bigint;
		enableLastSample ?: boolean;
		blocksize ?: number;
		renderDelay ?: number;
		throttleTime ?: number;
		maxBitrate ?: number;
		processingDeadline ?: number;
	}

	class BaseSrc extends Gst.Element {
		constructor(initializerList ?: BaseSrcCtor);

		element : Gst.Element;
		srcpad : Gst.Pad;
		liveCond : AuGlibEx.Cond;
		isLive : boolean;
		liveRunning : boolean;
		blocksize : number;
		canActivatePush : boolean;
		randomAccess : boolean;
		clockId : void;
		segment : Gst.Segment;
		needNewsegment : boolean;
		numBuffers : number;
		numBuffersLeft : number;
		typefind : boolean;
		running : boolean;
		pendingSeek : Gst.Event;
		priv : GstBase.BaseSrcPrivate;

		doTimestamp : boolean;

		getAllocator(allocator ?: Gst.Allocator | undefined | null, params ?: Gst.AllocationParams): void;
		getBlocksize(): number;
		getBufferPool(): Gst.BufferPool;
		getDoTimestamp(): boolean;
		isAsync(): boolean;
		negotiate(): boolean;
		newSeamlessSegment(start: number | bigint, stop: number | bigint, time: number | bigint): boolean;
		newSegment(segment: Gst.Segment): boolean;
		queryLatency(live ?: boolean, minLatency ?: number | bigint, maxLatency ?: number | bigint): boolean;
		setAsync(_async: boolean): void;
		setAutomaticEos(automaticEos: boolean): void;
		setBlocksize(blocksize: number): void;
		setCaps(caps: Gst.Caps): boolean;
		setDoTimestamp(timestamp: boolean): void;
		setDynamicSize(dynamic: boolean): void;
		setFormat(format: Gst.Format): void;
		setLive(live: boolean): void;
		startComplete(ret: Gst.FlowReturn): void;
		startWait(): Gst.FlowReturn;
		submitBufferList(bufferList: Gst.BufferList): void;
		waitPlaying(): Gst.FlowReturn;
		//TypeScript is complete garbage: 
	}

	class BaseSrcCtor {
		name ?: string;
		parent ?: Gst.Object;
		blocksize ?: number;
		numBuffers ?: number;
		typefind ?: boolean;
		doTimestamp ?: boolean;
	}

	class BaseTransform extends Gst.Element {
		constructor(initializerList ?: BaseTransformCtor);

		element : Gst.Element;
		sinkpad : Gst.Pad;
		srcpad : Gst.Pad;
		haveSegment : boolean;
		segment : Gst.Segment;
		queuedBuf : Gst.Buffer;
		priv : GstBase.BaseTransformPrivate;

		qos : boolean;

		getAllocator(allocator ?: Gst.Allocator | undefined | null, params ?: Gst.AllocationParams): void;
		getBufferPool(): Gst.BufferPool;
		isInPlace(): boolean;
		isPassthrough(): boolean;
		isQosEnabled(): boolean;
		reconfigure(): boolean;
		reconfigureSink(): void;
		reconfigureSrc(): void;
		setGapAware(gapAware: boolean): void;
		setInPlace(inPlace: boolean): void;
		setPassthrough(passthrough: boolean): void;
		setPreferPassthrough(preferPassthrough: boolean): void;
		setQosEnabled(enabled: boolean): void;
		updateQos(proportion: number, diff: number | bigint, timestamp: number | bigint): void;
		updateSrcCaps(updatedCaps: Gst.Caps): boolean;
		//TypeScript is complete garbage: 
	}

	class BaseTransformCtor {
		name ?: string;
		parent ?: Gst.Object;
		qos ?: boolean;
	}

	class CollectPads extends Gst.Object {
		constructor(initializerList ?: CollectPadsCtor);

		object : Gst.Object;
		data : GstBase.CollectData[];
		streamLock : AuGlibEx.RecMutex;
		priv : GstBase.CollectPadsPrivate;

		static New(): GstBase.CollectPads;
		addPad(pad: Gst.Pad, size: number, destroyNotify: (data: GstBase.CollectData) => void, lock: boolean): GstBase.CollectData;
		available(): number;
		clipRunningTime(cdata: GstBase.CollectData, buf: Gst.Buffer, outbuf ?: Gst.Buffer): Gst.FlowReturn;
		eventDefault(data: GstBase.CollectData, event: Gst.Event, discard: boolean): boolean;
		flush(data: GstBase.CollectData, size: number): number;
		peek(data: GstBase.CollectData): Gst.Buffer;
		pop(data: GstBase.CollectData): Gst.Buffer;
		queryDefault(data: GstBase.CollectData, query: Gst.Query, discard: boolean): boolean;
		readBuffer(data: GstBase.CollectData, size: number): Gst.Buffer;
		removePad(pad: Gst.Pad): boolean;
		setBufferFunction(func: (pads: GstBase.CollectPads, data: GstBase.CollectData, buffer: Gst.Buffer) => Gst.FlowReturn): void;
		setClipFunction(clipfunc: (pads: GstBase.CollectPads, data: GstBase.CollectData, inbuffer: Gst.Buffer, outbuffer: Gst.Buffer) => Gst.FlowReturn): void;
		setCompareFunction(func: (pads: GstBase.CollectPads, data1: GstBase.CollectData, timestamp1: number | bigint, data2: GstBase.CollectData, timestamp2: number | bigint) => number): void;
		setEventFunction(func: (pads: GstBase.CollectPads, pad: GstBase.CollectData, event: Gst.Event) => boolean): void;
		setFlushFunction(func: (pads: GstBase.CollectPads) => void): void;
		setFlushing(flushing: boolean): void;
		setFunction(func: (pads: GstBase.CollectPads) => Gst.FlowReturn): void;
		setQueryFunction(func: (pads: GstBase.CollectPads, pad: GstBase.CollectData, query: Gst.Query) => boolean): void;
		setWaiting(data: GstBase.CollectData, waiting: boolean): void;
		srcEventDefault(pad: Gst.Pad, event: Gst.Event): boolean;
		start(): void;
		stop(): void;
		takeBuffer(data: GstBase.CollectData, size: number): Gst.Buffer;
		//TypeScript is complete garbage: 
	}

	class CollectPadsCtor {
		name ?: string;
		parent ?: Gst.Object;
	}

	class DataQueue extends GObject.Object {
		constructor(initializerList ?: DataQueueCtor);

		object : GObject.Object;
		priv : GstBase.DataQueuePrivate;

		currentLevelBytes : number;
		currentLevelTime : number | bigint;
		currentLevelVisible : number;

		//TypeScript is complete garbage: 
	}

	class DataQueueCtor {
		currentLevelVisible ?: number;
		currentLevelBytes ?: number;
		currentLevelTime ?: number;
	}

	class PushSrc extends GstBase.BaseSrc {
		constructor(initializerList ?: PushSrcCtor);

		parent : GstBase.BaseSrc;

		//TypeScript is complete garbage: 
	}

	class PushSrcCtor {
		name ?: string;
		parent ?: Gst.Object;
		blocksize ?: number;
		numBuffers ?: number;
		typefind ?: boolean;
		doTimestamp ?: boolean;
	}
}