declare namespace GstPlayer {
	class PlayerColorBalanceType {
        // 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 "kHue": PlayerColorBalanceType
		static readonly "kBrightness": PlayerColorBalanceType
		static readonly "kSaturation": PlayerColorBalanceType
		static readonly "kContrast": PlayerColorBalanceType
	}

	class PlayerError {
        // 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 "kFailed": PlayerError
	}

	class PlayerSnapshotFormat {
        // 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 "kRawNative": PlayerSnapshotFormat
		static readonly "kRawXRgb": PlayerSnapshotFormat
		static readonly "kRawBgrx": PlayerSnapshotFormat
		static readonly "kJpg": PlayerSnapshotFormat
		static readonly "kPng": PlayerSnapshotFormat
	}

	class PlayerState {
        // 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 "kStopped": PlayerState
		static readonly "kBuffering": PlayerState
		static readonly "kPaused": PlayerState
		static readonly "kPlaying": PlayerState
	}


	class PlayerSignalDispatcher {
	}

	class PlayerVideoRenderer {
	}


	class PlayerAudioInfoClass {
	}

	class PlayerClass {
	}

	class PlayerGMainContextSignalDispatcherClass {
	}

	class PlayerMediaInfoClass {
	}

	class PlayerSignalDispatcherInterface {
		parentIface : GObject.TypeInterface;
		dispatch : (self: GstPlayer.PlayerSignalDispatcher, player: GstPlayer.Player, emitter: () => void, destroy: () => void) => void;

	}

	class PlayerStreamInfoClass {
	}

	class PlayerSubtitleInfoClass {
	}

	class PlayerVideoInfoClass {
	}

	class PlayerVideoOverlayVideoRendererClass {
	}

	class PlayerVideoRendererInterface {
		parentIface : GObject.TypeInterface;
		createVideoSink : void;

	}

	class PlayerVisualization {
		name : string;
		description : string;

		copy(): GstPlayer.PlayerVisualization;
		free(): void;
	}


	class Player extends Gst.Object {
		constructor(initializerList ?: PlayerCtor);

		audioVideoOffset : number | bigint;
		currentAudioTrack : GstPlayer.PlayerAudioInfo;
		currentSubtitleTrack : GstPlayer.PlayerSubtitleInfo;
		currentVideoTrack : GstPlayer.PlayerVideoInfo;
		duration : number | bigint;
		mediaInfo : GstPlayer.PlayerMediaInfo;
		mute : boolean;
		pipeline : Gst.Element;
		position : number | bigint;
		rate : number;
		signalDispatcher : GstPlayer.PlayerSignalDispatcher;
		subtitleVideoOffset : number | bigint;
		suburi : string;
		uri : string;
		videoMultiviewFlags : GstVideo.VideoMultiviewFlags;
		videoMultiviewMode : GstVideo.VideoMultiviewFramePacking;
		videoRenderer : GstPlayer.PlayerVideoRenderer;
		volume : number;

		static New(videoRenderer: GstPlayer.PlayerVideoRenderer | undefined | null, signalDispatcher: GstPlayer.PlayerSignalDispatcher | undefined | null): GstPlayer.Player;
		static ConfigGetPositionUpdateInterval(config: Gst.Structure): number;
		static ConfigGetSeekAccurate(config: Gst.Structure): boolean;
		static ConfigGetUserAgent(config: Gst.Structure): string;
		static ConfigSetPositionUpdateInterval(config: Gst.Structure, interval: number): void;
		static ConfigSetSeekAccurate(config: Gst.Structure, accurate: boolean): void;
		static ConfigSetUserAgent(config: Gst.Structure, agent: string | undefined | null): void;
		static GetAudioStreams(info: GstPlayer.PlayerMediaInfo): GstPlayer.PlayerAudioInfo[];
		static GetSubtitleStreams(info: GstPlayer.PlayerMediaInfo): GstPlayer.PlayerSubtitleInfo[];
		static GetVideoStreams(info: GstPlayer.PlayerMediaInfo): GstPlayer.PlayerVideoInfo[];
		static VisualizationsFree(viss: GstPlayer.PlayerVisualization): void;
		static VisualizationsGet(): GstPlayer.PlayerVisualization[];
		getAudioVideoOffset(): number | bigint;
		getColorBalance(type: GstPlayer.PlayerColorBalanceType): number;
		getConfig(): Gst.Structure;
		getCurrentAudioTrack(): GstPlayer.PlayerAudioInfo;
		getCurrentSubtitleTrack(): GstPlayer.PlayerSubtitleInfo;
		getCurrentVideoTrack(): GstPlayer.PlayerVideoInfo;
		getCurrentVisualization(): string;
		getDuration(): number | bigint;
		getMediaInfo(): GstPlayer.PlayerMediaInfo;
		getMultiviewFlags(): GstVideo.VideoMultiviewFlags;
		getMultiviewMode(): GstVideo.VideoMultiviewFramePacking;
		getMute(): boolean;
		getPipeline(): Gst.Element;
		getPosition(): number | bigint;
		getRate(): number;
		getSubtitleUri(): string;
		getSubtitleVideoOffset(): number | bigint;
		getUri(): string;
		getVideoSnapshot(format: GstPlayer.PlayerSnapshotFormat, config: Gst.Structure | undefined | null): Gst.Sample;
		getVolume(): number;
		hasColorBalance(): boolean;
		pause(): void;
		play(): void;
		seek(position: number | bigint): void;
		setAudioTrack(streamIndex: number): boolean;
		setAudioTrackEnabled(enabled: boolean): void;
		setAudioVideoOffset(offset: number | bigint): void;
		setColorBalance(type: GstPlayer.PlayerColorBalanceType, value: number): void;
		setConfig(config: Gst.Structure): boolean;
		setMultiviewFlags(flags: GstVideo.VideoMultiviewFlags): void;
		setMultiviewMode(mode: GstVideo.VideoMultiviewFramePacking): void;
		setMute(val: boolean): void;
		setRate(rate: number): void;
		setSubtitleTrack(streamIndex: number): boolean;
		setSubtitleTrackEnabled(enabled: boolean): void;
		setSubtitleUri(uri: string | undefined | null): void;
		setSubtitleVideoOffset(offset: number | bigint): void;
		setUri(uri: string | undefined | null): void;
		setVideoTrack(streamIndex: number): boolean;
		setVideoTrackEnabled(enabled: boolean): void;
		setVisualization(name: string | undefined | null): boolean;
		setVisualizationEnabled(enabled: boolean): void;
		setVolume(val: number): void;
		stop(): void;
		//TypeScript is complete garbage: 
	}

	class PlayerCtor {
		name ?: string;
		parent ?: Gst.Object;
		videoRenderer ?: GstPlayer.PlayerVideoRenderer;
		signalDispatcher ?: GstPlayer.PlayerSignalDispatcher;
		uri ?: string;
		suburi ?: string;
		position ?: number;
		duration ?: number;
		mediaInfo ?: GstPlayer.PlayerMediaInfo;
		currentAudioTrack ?: GstPlayer.PlayerAudioInfo;
		currentVideoTrack ?: GstPlayer.PlayerVideoInfo;
		currentSubtitleTrack ?: GstPlayer.PlayerSubtitleInfo;
		volume ?: number;
		mute ?: boolean;
		rate ?: number;
		pipeline ?: Gst.Element;
		videoMultiviewMode ?: GstVideo.VideoMultiviewFramePacking;
		videoMultiviewFlags ?: GstVideo.VideoMultiviewFlags;
		audioVideoOffset ?: number | bigint;
		subtitleVideoOffset ?: number | bigint;
	}

	class PlayerEventListener extends AuGlibEx.IEventListener {
		buffering(object: number): void;
		durationChanged(object: number | bigint): void;
		endOfStream(): void;
		error(object: AuGlibEx.Error): void;
		mediaInfoUpdated(object: GstPlayer.PlayerMediaInfo): void;
		muteChanged(): void;
		positionUpdated(object: number | bigint): void;
		seekDone(object: number | bigint): void;
		stateChanged(object: GstPlayer.PlayerState): void;
		uriLoaded(object: string): void;
		videoDimensionsChanged(object: number, p0: number): void;
		volumeChanged(): void;
		warning(object: AuGlibEx.Error): void;
	}

	class PlayerAudioInfo extends GstPlayer.PlayerStreamInfo {
		constructor(initializerList ?: PlayerAudioInfoCtor);

		getBitrate(): number;
		getChannels(): number;
		getLanguage(): string;
		getMaxBitrate(): number;
		getSampleRate(): number;
		//TypeScript is complete garbage: 
	}

	class PlayerAudioInfoCtor {
	}

	class PlayerGMainContextSignalDispatcher extends GObject.Object implements GstPlayer.PlayerSignalDispatcher {
		constructor(initializerList ?: PlayerGMainContextSignalDispatcherCtor);

		applicationContext : AuGlibEx.MainContext;

		static New(applicationContext: AuGlibEx.MainContext | undefined | null): GstPlayer.PlayerSignalDispatcher;
		//TypeScript is complete garbage: 
	}

	class PlayerGMainContextSignalDispatcherCtor {
		applicationContext ?: AuGlibEx.MainContext;
	}

	class PlayerMediaInfo extends GObject.Object {
		constructor(initializerList ?: PlayerMediaInfoCtor);

		getAudioStreams(): GstPlayer.PlayerAudioInfo[];
		getContainerFormat(): string;
		getDuration(): number | bigint;
		getImageSample(): Gst.Sample;
		getNumberOfAudioStreams(): number;
		getNumberOfStreams(): number;
		getNumberOfSubtitleStreams(): number;
		getNumberOfVideoStreams(): number;
		getStreamList(): GstPlayer.PlayerStreamInfo[];
		getSubtitleStreams(): GstPlayer.PlayerSubtitleInfo[];
		getTags(): Gst.TagList;
		getTitle(): string;
		getUri(): string;
		getVideoStreams(): GstPlayer.PlayerVideoInfo[];
		isLive(): boolean;
		isSeekable(): boolean;
		//TypeScript is complete garbage: 
	}

	class PlayerMediaInfoCtor {
	}

	class PlayerStreamInfo extends GObject.Object {
		constructor(initializerList ?: PlayerStreamInfoCtor);

		getCaps(): Gst.Caps;
		getCodec(): string;
		getIndex(): number;
		getStreamType(): string;
		getTags(): Gst.TagList;
		//TypeScript is complete garbage: 
	}

	class PlayerStreamInfoCtor {
	}

	class PlayerSubtitleInfo extends GstPlayer.PlayerStreamInfo {
		constructor(initializerList ?: PlayerSubtitleInfoCtor);

		getLanguage(): string;
		//TypeScript is complete garbage: 
	}

	class PlayerSubtitleInfoCtor {
	}

	class PlayerVideoInfo extends GstPlayer.PlayerStreamInfo {
		constructor(initializerList ?: PlayerVideoInfoCtor);

		getBitrate(): number;
		getFramerate(fpsN: number, fpsD: number): void;
		getHeight(): number;
		getMaxBitrate(): number;
		getPixelAspectRatio(parN: number, parD: number): void;
		getWidth(): number;
		//TypeScript is complete garbage: 
	}

	class PlayerVideoInfoCtor {
	}

	class PlayerVideoOverlayVideoRenderer extends GObject.Object implements GstPlayer.PlayerVideoRenderer {
		constructor(initializerList ?: PlayerVideoOverlayVideoRendererCtor);

		videoSink : Gst.Element;
		windowHandle : void;

		static New(): GstPlayer.PlayerVideoRenderer;
		static NewWithSink(videoSink: Gst.Element): GstPlayer.PlayerVideoRenderer;
		expose(): void;
		getRenderRectangle(x ?: number, y ?: number, width ?: number, height ?: number): void;
		getWindowHandle(): void;
		setRenderRectangle(x: number, y: number, width: number, height: number): void;
		setWindowHandle(): void;
		//TypeScript is complete garbage: 
	}

	class PlayerVideoOverlayVideoRendererCtor {
		windowHandle ?: number | bigint;
		videoSink ?: Gst.Element;
	}
}