GTK-TypeScript-Bindings/Gst.d.ts

declare namespace Gst {

	class AllocatorFlags {
        // 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 "kCustomAlloc": AllocatorFlags
		static readonly "kLast": AllocatorFlags
	}

	class BinFlags {
        // 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 "kNoResync": BinFlags
		static readonly "kStreamsAware": BinFlags
		static readonly "kLast": BinFlags
	}

	class BufferCopyFlags {
        // 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": BufferCopyFlags
		static readonly "kFlags": BufferCopyFlags
		static readonly "kTimestamps": BufferCopyFlags
		static readonly "kMeta": BufferCopyFlags
		static readonly "kMemory": BufferCopyFlags
		static readonly "kMerge": BufferCopyFlags
		static readonly "kDeep": BufferCopyFlags
	}

	class BufferFlags {
        // 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 "kLive": BufferFlags
		static readonly "kDecodeOnly": BufferFlags
		static readonly "kDiscont": BufferFlags
		static readonly "kResync": BufferFlags
		static readonly "kCorrupted": BufferFlags
		static readonly "kMarker": BufferFlags
		static readonly "kHeader": BufferFlags
		static readonly "kGap": BufferFlags
		static readonly "kDroppable": BufferFlags
		static readonly "kDeltaUnit": BufferFlags
		static readonly "kTagMemory": BufferFlags
		static readonly "kSyncAfter": BufferFlags
		static readonly "kNonDroppable": BufferFlags
		static readonly "kLast": BufferFlags
	}

	class BufferPoolAcquireFlags {
        // 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": BufferPoolAcquireFlags
		static readonly "kKeyUnit": BufferPoolAcquireFlags
		static readonly "kDontwait": BufferPoolAcquireFlags
		static readonly "kDiscont": BufferPoolAcquireFlags
		static readonly "kLast": BufferPoolAcquireFlags
	}

	class BufferingMode {
        // 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 "kStream": BufferingMode
		static readonly "kDownload": BufferingMode
		static readonly "kTimeshift": BufferingMode
		static readonly "kLive": BufferingMode
	}

	class BusFlags {
        // 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 "kFlushing": BusFlags
		static readonly "kFlagLast": BusFlags
	}

	class BusSyncReply {
        // 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 "kDrop": BusSyncReply
		static readonly "kPass": BusSyncReply
		static readonly "kAsync": BusSyncReply
	}

	class CapsFlags {
        // 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 "kAny": CapsFlags
	}

	class CapsIntersectMode {
        // 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 "kZigZag": CapsIntersectMode
		static readonly "kFirst": CapsIntersectMode
	}

	class ClockEntryType {
        // 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 "kSingle": ClockEntryType
		static readonly "kPeriodic": ClockEntryType
	}

	class ClockFlags {
        // 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 "kCanDoSingleSync": ClockFlags
		static readonly "kCanDoSingleAsync": ClockFlags
		static readonly "kCanDoPeriodicSync": ClockFlags
		static readonly "kCanDoPeriodicAsync": ClockFlags
		static readonly "kCanSetResolution": ClockFlags
		static readonly "kCanSetMaster": ClockFlags
		static readonly "kNeedsStartupSync": ClockFlags
		static readonly "kLast": ClockFlags
	}

	class ClockReturn {
        // 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 "kOk": ClockReturn
		static readonly "kEarly": ClockReturn
		static readonly "kUnscheduled": ClockReturn
		static readonly "kBusy": ClockReturn
		static readonly "kBadtime": ClockReturn
		static readonly "kError": ClockReturn
		static readonly "kUnsupported": ClockReturn
		static readonly "kDone": ClockReturn
	}

	class ClockType {
        // 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 "kRealtime": ClockType
		static readonly "kMonotonic": ClockType
		static readonly "kOther": ClockType
		static readonly "kTai": ClockType
	}

	class CoreError {
        // 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": CoreError
		static readonly "kTooLazy": CoreError
		static readonly "kNotImplemented": CoreError
		static readonly "kStateChange": CoreError
		static readonly "kPad": CoreError
		static readonly "kThread": CoreError
		static readonly "kNegotiation": CoreError
		static readonly "kEvent": CoreError
		static readonly "kSeek": CoreError
		static readonly "kCaps": CoreError
		static readonly "kTag": CoreError
		static readonly "kMissingPlugin": CoreError
		static readonly "kClock": CoreError
		static readonly "kDisabled": CoreError
		static readonly "kNumErrors": CoreError
	}

	class DebugColorFlags {
        // 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 "kFgBlack": DebugColorFlags
		static readonly "kFgRed": DebugColorFlags
		static readonly "kFgGreen": DebugColorFlags
		static readonly "kFgYEllow": DebugColorFlags
		static readonly "kFgBlue": DebugColorFlags
		static readonly "kFgMagenta": DebugColorFlags
		static readonly "kFgCyan": DebugColorFlags
		static readonly "kFgWhite": DebugColorFlags
		static readonly "kBgBlack": DebugColorFlags
		static readonly "kBgRed": DebugColorFlags
		static readonly "kBgGreen": DebugColorFlags
		static readonly "kBgYEllow": DebugColorFlags
		static readonly "kBgBlue": DebugColorFlags
		static readonly "kBgMagenta": DebugColorFlags
		static readonly "kBgCyan": DebugColorFlags
		static readonly "kBgWhite": DebugColorFlags
		static readonly "kBold": DebugColorFlags
		static readonly "kUnderline": DebugColorFlags
	}

	class DebugColorMode {
        // 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 "kOff": DebugColorMode
		static readonly "kOn": DebugColorMode
		static readonly "kUnix": DebugColorMode
	}

	class DebugGraphDetails {
        // 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 "kMediaType": DebugGraphDetails
		static readonly "kCapsDetails": DebugGraphDetails
		static readonly "kNonDefaultParams": DebugGraphDetails
		static readonly "kStates": DebugGraphDetails
		static readonly "kFullParams": DebugGraphDetails
		static readonly "kAll": DebugGraphDetails
		static readonly "kVerbose": DebugGraphDetails
	}

	class DebugLevel {
        // 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": DebugLevel
		static readonly "kError": DebugLevel
		static readonly "kWarning": DebugLevel
		static readonly "kFixme": DebugLevel
		static readonly "kInfo": DebugLevel
		static readonly "kDebug": DebugLevel
		static readonly "kLog": DebugLevel
		static readonly "kTrace": DebugLevel
		static readonly "kMemdump": DebugLevel
		static readonly "kCount": DebugLevel
	}

	class ElementFlags {
        // 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 "kLockedState": ElementFlags
		static readonly "kSink": ElementFlags
		static readonly "kSource": ElementFlags
		static readonly "kProvideClock": ElementFlags
		static readonly "kRequireClock": ElementFlags
		static readonly "kIndexable": ElementFlags
		static readonly "kLast": ElementFlags
	}

	class EventType {
        // 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": EventType
		static readonly "kFlushStart": EventType
		static readonly "kFlushStop": EventType
		static readonly "kStreamStart": EventType
		static readonly "kCaps": EventType
		static readonly "kSegment": EventType
		static readonly "kStreamCollection": EventType
		static readonly "kTag": EventType
		static readonly "kBuffersize": EventType
		static readonly "kSinkMessage": EventType
		static readonly "kStreamGroupDone": EventType
		static readonly "kEos": EventType
		static readonly "kToc": EventType
		static readonly "kProtection": EventType
		static readonly "kSegmentDone": EventType
		static readonly "kGap": EventType
		static readonly "kInstantRateChange": EventType
		static readonly "kQos": EventType
		static readonly "kSeek": EventType
		static readonly "kNavigation": EventType
		static readonly "kLatency": EventType
		static readonly "kStep": EventType
		static readonly "kReconfigure": EventType
		static readonly "kTocSelect": EventType
		static readonly "kSelectStreams": EventType
		static readonly "kInstantRateSyncTime": EventType
		static readonly "kCustomUpstream": EventType
		static readonly "kCustomDownstream": EventType
		static readonly "kCustomDownstreamOob": EventType
		static readonly "kCustomDownstreamSticky": EventType
		static readonly "kCustomBoth": EventType
		static readonly "kCustomBothOob": EventType
	}

	class EventTypeFlags {
        // 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 "kUpstream": EventTypeFlags
		static readonly "kDownstream": EventTypeFlags
		static readonly "kSerialized": EventTypeFlags
		static readonly "kSticky": EventTypeFlags
		static readonly "kStickyMulti": EventTypeFlags
	}

	class FlowReturn {
        // 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 "kCustomSuccess2": FlowReturn
		static readonly "kCustomSuccess1": FlowReturn
		static readonly "kCustomSuccess": FlowReturn
		static readonly "kOk": FlowReturn
		static readonly "kNotLinked": FlowReturn
		static readonly "kFlushing": FlowReturn
		static readonly "kEos": FlowReturn
		static readonly "kNotNegotiated": FlowReturn
		static readonly "kError": FlowReturn
		static readonly "kNotSupported": FlowReturn
		static readonly "kCustomError": FlowReturn
		static readonly "kCustomError1": FlowReturn
		static readonly "kCustomError2": FlowReturn
	}

	class Format {
        // 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 "kUndefined": Format
		static readonly "kDefault": Format
		static readonly "kBytes": Format
		static readonly "kTime": Format
		static readonly "kBuffers": Format
		static readonly "kPercent": Format
	}

	class GapFlags {
        // 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 "kData": GapFlags
	}

	class IteratorItem {
        // 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 "kSkip": IteratorItem
		static readonly "kPass": IteratorItem
		static readonly "kEnd": IteratorItem
	}

	class IteratorResult {
        // 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 "kDone": IteratorResult
		static readonly "kOk": IteratorResult
		static readonly "kResync": IteratorResult
		static readonly "kError": IteratorResult
	}

	class LibraryError {
        // 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": LibraryError
		static readonly "kTooLazy": LibraryError
		static readonly "kInit": LibraryError
		static readonly "kShutdown": LibraryError
		static readonly "kSettings": LibraryError
		static readonly "kEncode": LibraryError
		static readonly "kNumErrors": LibraryError
	}

	class LockFlags {
        // 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 "kRead": LockFlags
		static readonly "kWrite": LockFlags
		static readonly "kExclusive": LockFlags
		static readonly "kLast": LockFlags
	}

	class MapFlags {
        // 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 "kRead": MapFlags
		static readonly "kWrite": MapFlags
		static readonly "kFlagLast": MapFlags
	}

	class MemoryFlags {
        // 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 "kReadonly": MemoryFlags
		static readonly "kNoShare": MemoryFlags
		static readonly "kZeroPrefixed": MemoryFlags
		static readonly "kZeroPadded": MemoryFlags
		static readonly "kPhysicallyContiguous": MemoryFlags
		static readonly "kNotMappable": MemoryFlags
		static readonly "kLast": MemoryFlags
	}

	class MessageType {
        // 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": MessageType
		static readonly "kEos": MessageType
		static readonly "kError": MessageType
		static readonly "kWarning": MessageType
		static readonly "kInfo": MessageType
		static readonly "kTag": MessageType
		static readonly "kBuffering": MessageType
		static readonly "kStateChanged": MessageType
		static readonly "kStateDirty": MessageType
		static readonly "kStepDone": MessageType
		static readonly "kClockProvide": MessageType
		static readonly "kClockLost": MessageType
		static readonly "kNewClock": MessageType
		static readonly "kStructureChange": MessageType
		static readonly "kStreamStatus": MessageType
		static readonly "kApplication": MessageType
		static readonly "kElement": MessageType
		static readonly "kSegmentStart": MessageType
		static readonly "kSegmentDone": MessageType
		static readonly "kDurationChanged": MessageType
		static readonly "kLatency": MessageType
		static readonly "kAsyncStart": MessageType
		static readonly "kAsyncDone": MessageType
		static readonly "kRequestState": MessageType
		static readonly "kStepStart": MessageType
		static readonly "kQos": MessageType
		static readonly "kProgress": MessageType
		static readonly "kToc": MessageType
		static readonly "kResetTime": MessageType
		static readonly "kStreamStart": MessageType
		static readonly "kNeedContext": MessageType
		static readonly "kHaveContext": MessageType
		static readonly "kExtended": MessageType
		static readonly "kDeviceAdded": MessageType
		static readonly "kDeviceRemoved": MessageType
		static readonly "kPropertyNotify": MessageType
		static readonly "kStreamCollection": MessageType
		static readonly "kStreamsSelected": MessageType
		static readonly "kRedirect": MessageType
		static readonly "kDeviceChanged": MessageType
		static readonly "kInstantRateRequest": MessageType
		static readonly "kAny": MessageType
	}

	class MetaFlags {
        // 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": MetaFlags
		static readonly "kReadonly": MetaFlags
		static readonly "kPooled": MetaFlags
		static readonly "kLocked": MetaFlags
		static readonly "kLast": MetaFlags
	}

	class MiniObjectFlags {
        // 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 "kLockable": MiniObjectFlags
		static readonly "kLockReadonly": MiniObjectFlags
		static readonly "kMayBeLeaked": MiniObjectFlags
		static readonly "kLast": MiniObjectFlags
	}

	class ObjectFlags {
        // 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 "kMayBeLeaked": ObjectFlags
		static readonly "kLast": ObjectFlags
	}

	class PadDirection {
        // 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": PadDirection
		static readonly "kSrc": PadDirection
		static readonly "kSink": PadDirection
	}

	class PadFlags {
        // 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 "kBlocked": PadFlags
		static readonly "kFlushing": PadFlags
		static readonly "kEos": PadFlags
		static readonly "kBlocking": PadFlags
		static readonly "kNeedParent": PadFlags
		static readonly "kNeedReconfigure": PadFlags
		static readonly "kPendingEvents": PadFlags
		static readonly "kFixedCaps": PadFlags
		static readonly "kProxyCaps": PadFlags
		static readonly "kProxyAllocation": PadFlags
		static readonly "kProxyScheduling": PadFlags
		static readonly "kAcceptIntersect": PadFlags
		static readonly "kAcceptTemplate": PadFlags
		static readonly "kLast": PadFlags
	}

	class PadLinkCheck {
        // 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 "kNothing": PadLinkCheck
		static readonly "kHierarchy": PadLinkCheck
		static readonly "kTemplateCaps": PadLinkCheck
		static readonly "kCaps": PadLinkCheck
		static readonly "kNoReconfigure": PadLinkCheck
		static readonly "kDefault": PadLinkCheck
	}

	class PadLinkReturn {
        // 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 "kOk": PadLinkReturn
		static readonly "kWrongHierarchy": PadLinkReturn
		static readonly "kWasLinked": PadLinkReturn
		static readonly "kWrongDirection": PadLinkReturn
		static readonly "kNoformat": PadLinkReturn
		static readonly "kNosched": PadLinkReturn
		static readonly "kRefused": PadLinkReturn
	}

	class PadMode {
        // 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": PadMode
		static readonly "kPush": PadMode
		static readonly "kPull": PadMode
	}

	class PadPresence {
        // 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 "kAlways": PadPresence
		static readonly "kSometimes": PadPresence
		static readonly "kRequest": PadPresence
	}

	class PadProbeReturn {
        // 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 "kDrop": PadProbeReturn
		static readonly "kOk": PadProbeReturn
		static readonly "kRemove": PadProbeReturn
		static readonly "kPass": PadProbeReturn
		static readonly "kHandled": PadProbeReturn
	}

	class PadProbeType {
        // 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 "kInvalid": PadProbeType
		static readonly "kIdle": PadProbeType
		static readonly "kBlock": PadProbeType
		static readonly "kBuffer": PadProbeType
		static readonly "kBufferList": PadProbeType
		static readonly "kEventDownstream": PadProbeType
		static readonly "kEventUpstream": PadProbeType
		static readonly "kEventFlush": PadProbeType
		static readonly "kQueryDownstream": PadProbeType
		static readonly "kQueryUpstream": PadProbeType
		static readonly "kPush": PadProbeType
		static readonly "kPull": PadProbeType
		static readonly "kBlocking": PadProbeType
		static readonly "kDataDownstream": PadProbeType
		static readonly "kDataUpstream": PadProbeType
		static readonly "kDataBoth": PadProbeType
		static readonly "kBlockDownstream": PadProbeType
		static readonly "kBlockUpstream": PadProbeType
		static readonly "kEventBoth": PadProbeType
		static readonly "kQueryBoth": PadProbeType
		static readonly "kAllBoth": PadProbeType
		static readonly "kScheduling": PadProbeType
	}

	class PadTemplateFlags {
        // 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 "kLast": PadTemplateFlags
	}

	class ParseError {
        // 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 "kSyntax": ParseError
		static readonly "kNoSuchElement": ParseError
		static readonly "kNoSuchProperty": ParseError
		static readonly "kLink": ParseError
		static readonly "kCouldNotSetProperty": ParseError
		static readonly "kEmptyBin": ParseError
		static readonly "kEmpty": ParseError
		static readonly "kDelayedLink": ParseError
	}

	class ParseFlags {
        // 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": ParseFlags
		static readonly "kFatalErrors": ParseFlags
		static readonly "kNoSingleElementBins": ParseFlags
		static readonly "kPlaceInBin": ParseFlags
	}

	class PipelineFlags {
        // 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 "kFixedClock": PipelineFlags
		static readonly "kLast": PipelineFlags
	}

	class PluginAPIFlags {
        // 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 "kMembers": PluginAPIFlags
	}

	class PluginDependencyFlags {
        // 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": PluginDependencyFlags
		static readonly "kRecurse": PluginDependencyFlags
		static readonly "kPathsAreDefaultOnly": PluginDependencyFlags
		static readonly "kFileNameIsSuffix": PluginDependencyFlags
		static readonly "kFileNameIsPrefix": PluginDependencyFlags
		static readonly "kPathsAreRelativeToExe": PluginDependencyFlags
	}

	class PluginError {
        // 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 "kModule": PluginError
		static readonly "kDependencies": PluginError
		static readonly "kNameMismatch": PluginError
	}

	class PluginFlags {
        // 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 "kCached": PluginFlags
		static readonly "kBlacklisted": PluginFlags
	}

	class ProgressType {
        // 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 "kStart": ProgressType
		static readonly "kContinue": ProgressType
		static readonly "kComplete": ProgressType
		static readonly "kCanceled": ProgressType
		static readonly "kError": ProgressType
	}

	class PromiseResult {
        // 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 "kPending": PromiseResult
		static readonly "kInterrupted": PromiseResult
		static readonly "kReplied": PromiseResult
		static readonly "kExpired": PromiseResult
	}

	class QOSType {
        // 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 "kOverflow": QOSType
		static readonly "kUnderflow": QOSType
		static readonly "kThrottle": QOSType
	}

	class QueryType {
        // 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": QueryType
		static readonly "kPosition": QueryType
		static readonly "kDuration": QueryType
		static readonly "kLatency": QueryType
		static readonly "kJitter": QueryType
		static readonly "kRate": QueryType
		static readonly "kSeeking": QueryType
		static readonly "kSegment": QueryType
		static readonly "kConvert": QueryType
		static readonly "kFormats": QueryType
		static readonly "kBuffering": QueryType
		static readonly "kCustom": QueryType
		static readonly "kUri": QueryType
		static readonly "kAllocation": QueryType
		static readonly "kScheduling": QueryType
		static readonly "kAcceptCaps": QueryType
		static readonly "kCaps": QueryType
		static readonly "kDrain": QueryType
		static readonly "kContext": QueryType
		static readonly "kBitrate": QueryType
	}

	class QueryTypeFlags {
        // 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 "kUpstream": QueryTypeFlags
		static readonly "kDownstream": QueryTypeFlags
		static readonly "kSerialized": QueryTypeFlags
	}

	class Rank {
        // 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": Rank
		static readonly "kMarginal": Rank
		static readonly "kSecondary": Rank
		static readonly "kPrimary": Rank
	}

	class ResourceError {
        // 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": ResourceError
		static readonly "kTooLazy": ResourceError
		static readonly "kNotFound": ResourceError
		static readonly "kBusy": ResourceError
		static readonly "kOpenRead": ResourceError
		static readonly "kOpenWrite": ResourceError
		static readonly "kOpenReadWrite": ResourceError
		static readonly "kClose": ResourceError
		static readonly "kRead": ResourceError
		static readonly "kWrite": ResourceError
		static readonly "kSeek": ResourceError
		static readonly "kSync": ResourceError
		static readonly "kSettings": ResourceError
		static readonly "kNoSpaceLeft": ResourceError
		static readonly "kNotAuthorized": ResourceError
		static readonly "kNumErrors": ResourceError
	}

	class SchedulingFlags {
        // 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 "kSeekable": SchedulingFlags
		static readonly "kSequential": SchedulingFlags
		static readonly "kBandwidthLimited": SchedulingFlags
	}

	class SearchMode {
        // 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 "kExact": SearchMode
		static readonly "kBefore": SearchMode
		static readonly "kAfter": SearchMode
	}

	class SeekFlags {
        // 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": SeekFlags
		static readonly "kFlush": SeekFlags
		static readonly "kAccurate": SeekFlags
		static readonly "kKeyUnit": SeekFlags
		static readonly "kSegment": SeekFlags
		static readonly "kTrickmode": SeekFlags
		static readonly "kSkip": SeekFlags
		static readonly "kSnapBefore": SeekFlags
		static readonly "kSnapAfter": SeekFlags
		static readonly "kSnapNearest": SeekFlags
		static readonly "kTrickmodeKeyUnits": SeekFlags
		static readonly "kTrickmodeNoAudio": SeekFlags
		static readonly "kTrickmodeForwardPredicted": SeekFlags
		static readonly "kInstantRateChange": SeekFlags
	}

	class SeekType {
        // 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": SeekType
		static readonly "kSet": SeekType
		static readonly "kEnd": SeekType
	}

	class SegmentFlags {
        // 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": SegmentFlags
		static readonly "kReset": SegmentFlags
		static readonly "kTrickmode": SegmentFlags
		static readonly "kSkip": SegmentFlags
		static readonly "kSegment": SegmentFlags
		static readonly "kTrickmodeKeyUnits": SegmentFlags
		static readonly "kTrickmodeForwardPredicted": SegmentFlags
		static readonly "kTrickmodeNoAudio": SegmentFlags
	}

	class SerializeFlags {
        // 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": SerializeFlags
		static readonly "kBackwardCompat": SerializeFlags
	}

	class StackTraceFlags {
        // 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": StackTraceFlags
		static readonly "kFull": StackTraceFlags
	}

	class State {
        // 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 "kVoidPending": State
		static readonly "kNull": State
		static readonly "kReady": State
		static readonly "kPaused": State
		static readonly "kPlaying": State
	}

	class StateChange {
        // 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 "kNullToReady": StateChange
		static readonly "kReadyToPaused": StateChange
		static readonly "kPausedToPlaying": StateChange
		static readonly "kPlayingToPaused": StateChange
		static readonly "kPausedToReady": StateChange
		static readonly "kReadyToNull": StateChange
		static readonly "kNullToNull": StateChange
		static readonly "kReadyToReady": StateChange
		static readonly "kPausedToPaused": StateChange
		static readonly "kPlayingToPlaying": StateChange
	}

	class StateChangeReturn {
        // 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 "kFailure": StateChangeReturn
		static readonly "kSuccess": StateChangeReturn
		static readonly "kAsync": StateChangeReturn
		static readonly "kNoPreroll": StateChangeReturn
	}

	class StreamError {
        // 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": StreamError
		static readonly "kTooLazy": StreamError
		static readonly "kNotImplemented": StreamError
		static readonly "kTypeNotFound": StreamError
		static readonly "kWrongType": StreamError
		static readonly "kCodecNotFound": StreamError
		static readonly "kDecode": StreamError
		static readonly "kEncode": StreamError
		static readonly "kDemux": StreamError
		static readonly "kMux": StreamError
		static readonly "kFormat": StreamError
		static readonly "kDecrypt": StreamError
		static readonly "kDecryptNokey": StreamError
		static readonly "kNumErrors": StreamError
	}

	class StreamFlags {
        // 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": StreamFlags
		static readonly "kSparse": StreamFlags
		static readonly "kSelect": StreamFlags
		static readonly "kUnselect": StreamFlags
	}

	class StreamStatusType {
        // 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 "kCreate": StreamStatusType
		static readonly "kEnter": StreamStatusType
		static readonly "kLeave": StreamStatusType
		static readonly "kDestroy": StreamStatusType
		static readonly "kStart": StreamStatusType
		static readonly "kPause": StreamStatusType
		static readonly "kStop": StreamStatusType
	}

	class StreamType {
        // 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": StreamType
		static readonly "kAudio": StreamType
		static readonly "kVideo": StreamType
		static readonly "kContainer": StreamType
		static readonly "kText": StreamType
	}

	class StructureChangeType {
        // 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 "kLink": StructureChangeType
		static readonly "kUnlink": StructureChangeType
	}

	class TagFlag {
        // 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 "kUndefined": TagFlag
		static readonly "kMeta": TagFlag
		static readonly "kEncoded": TagFlag
		static readonly "kDecoded": TagFlag
		static readonly "kCount": TagFlag
	}

	class TagMergeMode {
        // 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 "kUndefined": TagMergeMode
		static readonly "kReplaceAll": TagMergeMode
		static readonly "kReplace": TagMergeMode
		static readonly "kAppend": TagMergeMode
		static readonly "kPrepend": TagMergeMode
		static readonly "kKeep": TagMergeMode
		static readonly "kKeepAll": TagMergeMode
		static readonly "kCount": TagMergeMode
	}

	class TagScope {
        // 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 "kStream": TagScope
		static readonly "kGlobal": TagScope
	}

	class TaskState {
        // 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 "kStarted": TaskState
		static readonly "kStopped": TaskState
		static readonly "kPaused": TaskState
	}

	class TocEntryType {
        // 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 "kAngle": TocEntryType
		static readonly "kVersion": TocEntryType
		static readonly "kEdition": TocEntryType
		static readonly "kInvalid": TocEntryType
		static readonly "kTitle": TocEntryType
		static readonly "kTrack": TocEntryType
		static readonly "kChapter": TocEntryType
	}

	class TocLoopType {
        // 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": TocLoopType
		static readonly "kForward": TocLoopType
		static readonly "kReverse": TocLoopType
		static readonly "kPingPong": TocLoopType
	}

	class TocScope {
        // 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 "kGlobal": TocScope
		static readonly "kCurrent": TocScope
	}

	class TracerValueFlags {
        // 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": TracerValueFlags
		static readonly "kOptional": TracerValueFlags
		static readonly "kAggregated": TracerValueFlags
	}

	class TracerValueScope {
        // 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 "kProcess": TracerValueScope
		static readonly "kThread": TracerValueScope
		static readonly "kElement": TracerValueScope
		static readonly "kPad": TracerValueScope
	}

	class TypeFindProbability {
        // 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": TypeFindProbability
		static readonly "kMinimum": TypeFindProbability
		static readonly "kPossible": TypeFindProbability
		static readonly "kLikely": TypeFindProbability
		static readonly "kNearlyCertain": TypeFindProbability
		static readonly "kMaximum": TypeFindProbability
	}

	class URIError {
        // 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 "kUnsupportedProtocol": URIError
		static readonly "kBadUri": URIError
		static readonly "kBadState": URIError
		static readonly "kBadReference": URIError
	}

	class URIType {
        // 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": URIType
		static readonly "kSink": URIType
		static readonly "kSrc": URIType
	}


	class ChildProxy {
		childAdded(child: GObject.Object, name: string): void;
		childRemoved(child: GObject.Object, name: string): void;
		getChildByIndex(index: number): GObject.Object;
		getChildByName(name: string): GObject.Object;
		getChildrenCount(): number;
		getProperty(name: string, value: GObject.Value): void;
		lookup(name: string, target ?: GObject.Object, pspec ?: GObject.ParamSpec): boolean;
		setProperty(name: string, value: GObject.Value): void;
	}

	class Preset {
		static GetAppDir(): string;
		static SetAppDir(appDir: string): boolean;
		deletePreset(name: string): boolean;
		getMeta(name: string, tag: string, value: string): boolean;
		getPresetNames(): string[];
		getPropertyNames(): string[];
		isEditable(): boolean;
		loadPreset(name: string): boolean;
		renamePreset(oldName: string, newName: string): boolean;
		savePreset(name: string): boolean;
		setMeta(name: string, tag: string, value: string | undefined | null): boolean;
	}

	class TagSetter {
		addTagValue(mode: Gst.TagMergeMode, tag: string, value: GObject.Value): void;
		getTagList(): Gst.TagList;
		getTagMergeMode(): Gst.TagMergeMode;
		mergeTags(list: Gst.TagList, mode: Gst.TagMergeMode): void;
		resetTags(): void;
		setTagMergeMode(mode: Gst.TagMergeMode): void;
	}

	class TocSetter {
		getToc(): Gst.Toc;
		reset(): void;
		setToc(toc: Gst.Toc | undefined | null): void;
	}

	class URIHandler {
		getProtocols(): string[];
		getUri(): string;
		getUriType(): Gst.URIType;
		setUri(uri: string): boolean;
	}


	class AllocationParams {
		flags : Gst.MemoryFlags;
		align : number | bigint;
		prefix : number | bigint;
		padding : number | bigint;

		static New(): Gst.AllocationParams;
		copy(): Gst.AllocationParams;
		free(): void;
		init(): void;
	}

	class AllocatorClass {
		objectClass : Gst.ObjectClass;
		alloc : (allocator: Gst.Allocator | undefined | null, size: number | bigint, params: Gst.AllocationParams | undefined | null) => Gst.Memory;
		free : (allocator: Gst.Allocator, memory: Gst.Memory) => void;

	}

	class AllocatorPrivate {
	}

	class AtomicQueue {
		static New(initialSize: number): Gst.AtomicQueue;
		length(): number;
		peek(): void;
		pop(): void;
		push(): void;
		ref(): void;
		unref(): void;
	}

	class BinClass {
		parentClass : Gst.ElementClass;
		pool : AuGlibEx.ThreadPool;
		elementAdded : (bin: Gst.Bin, child: Gst.Element) => void;
		elementRemoved : (bin: Gst.Bin, child: Gst.Element) => void;
		addElement : (bin: Gst.Bin, element: Gst.Element) => boolean;
		removeElement : (bin: Gst.Bin, element: Gst.Element) => boolean;
		handleMessage : (bin: Gst.Bin, message: Gst.Message) => void;
		doLatency : (bin: Gst.Bin) => boolean;
		deepElementAdded : (bin: Gst.Bin, subBin: Gst.Bin, child: Gst.Element) => void;
		deepElementRemoved : (bin: Gst.Bin, subBin: Gst.Bin, child: Gst.Element) => void;

	}

	class BinPrivate {
	}

	class Buffer {
		miniObject : Gst.MiniObject;
		pool : Gst.BufferPool;
		pts : number | bigint;
		dts : number | bigint;
		duration : number | bigint;
		offset : number | bigint;
		offsetEnd : number | bigint;

		static New(): Gst.Buffer;
		static NewAllocate(allocator: Gst.Allocator | undefined | null, size: number | bigint, params: Gst.AllocationParams | undefined | null): Gst.Buffer;
		static NewMemdup(data: number[], size: number | bigint): Gst.Buffer;
		static NewWrapped(data: number[], size: number | bigint): Gst.Buffer;
		static NewWrappedBytes(bytes: AuGlibEx.Bytes): Gst.Buffer;
		static NewWrappedFull(flags: Gst.MemoryFlags, data: number[], maxsize: number | bigint, offset: number | bigint, size: number | bigint, notify: () => void | undefined | null): Gst.Buffer;
		addCustomMeta(name: string): Gst.CustomMeta;
		addMeta(info: Gst.MetaInfo): Gst.Meta;
		addParentBufferMeta(ref: Gst.Buffer): Gst.ParentBufferMeta;
		addProtectionMeta(info: Gst.Structure): Gst.ProtectionMeta;
		addReferenceTimestampMeta(reference: Gst.Caps, timestamp: number | bigint, duration: number | bigint): Gst.ReferenceTimestampMeta;
		append(buf2: Gst.Buffer): Gst.Buffer;
		appendMemory(mem: Gst.Memory): void;
		appendRegion(buf2: Gst.Buffer, offset: number | bigint, size: number | bigint): Gst.Buffer;
		copyDeep(): Gst.Buffer;
		copyInto(src: Gst.Buffer, flags: Gst.BufferCopyFlags, offset: number | bigint, size: number | bigint): boolean;
		copyRegion(flags: Gst.BufferCopyFlags, offset: number | bigint, size: number | bigint): Gst.Buffer;
		extract(offset: number | bigint, dest: number[], size: number | bigint): number | bigint;
		extractDup(offset: number | bigint, size: number | bigint, dest: number[], destSize: number | bigint): void;
		fill(offset: number | bigint, src: number[], size: number | bigint): number | bigint;
		findMemory(offset: number | bigint, size: number | bigint, idx: number, length: number, skip: number | bigint): boolean;
		foreachMeta(func: (buffer: Gst.Buffer, meta: Gst.Meta | undefined | null) => boolean): boolean;
		getAllMemory(): Gst.Memory;
		getCustomMeta(name: string): Gst.CustomMeta;
		getFlags(): Gst.BufferFlags;
		getMemory(idx: number): Gst.Memory;
		getMemoryRange(idx: number, length: number): Gst.Memory;
		getMeta(api: number): Gst.Meta;
		getNMeta(apiType: number): number;
		getReferenceTimestampMeta(reference: Gst.Caps | undefined | null): Gst.ReferenceTimestampMeta;
		getSize(): number | bigint;
		getSizes(offset ?: number | bigint, maxsize ?: number | bigint): number | bigint;
		getSizesRange(idx: number, length: number, offset ?: number | bigint, maxsize ?: number | bigint): number | bigint;
		hasFlags(flags: Gst.BufferFlags): boolean;
		insertMemory(idx: number, mem: Gst.Memory): void;
		isAllMemoryWritable(): boolean;
		isMemoryRangeWritable(idx: number, length: number): boolean;
		map(info: Gst.MapInfo, flags: Gst.MapFlags): boolean;
		mapRange(idx: number, length: number, info: Gst.MapInfo, flags: Gst.MapFlags): boolean;
		memcmp(offset: number | bigint, mem: number[], size: number | bigint): number;
		memset(offset: number | bigint, val: number, size: number | bigint): number | bigint;
		nMemory(): number;
		peekMemory(idx: number): Gst.Memory;
		prependMemory(mem: Gst.Memory): void;
		removeAllMemory(): void;
		removeMemory(idx: number): void;
		removeMemoryRange(idx: number, length: number): void;
		removeMeta(meta: Gst.Meta): boolean;
		replaceAllMemory(mem: Gst.Memory): void;
		replaceMemory(idx: number, mem: Gst.Memory): void;
		replaceMemoryRange(idx: number, length: number, mem: Gst.Memory): void;
		resize(offset: number | bigint, size: number | bigint): void;
		resizeRange(idx: number, length: number, offset: number | bigint, size: number | bigint): boolean;
		setFlags(flags: Gst.BufferFlags): boolean;
		setSize(size: number | bigint): void;
		unmap(info: Gst.MapInfo): void;
		unsetFlags(flags: Gst.BufferFlags): boolean;
		static GetMaxMemory(): number;
	}

	class BufferList {
		static New(): Gst.BufferList;
		static NewSized(size: number): Gst.BufferList;
		calculateSize(): number | bigint;
		copyDeep(): Gst.BufferList;
		foreach(func: (buffer: Gst.Buffer | undefined | null, idx: number) => boolean): boolean;
		get(idx: number): Gst.Buffer;
		getWritable(idx: number): Gst.Buffer;
		insert(idx: number, buffer: Gst.Buffer): void;
		length(): number;
		remove(idx: number, length: number): void;
	}

	class BufferPoolAcquireParams {
		format : Gst.Format;
		start : number | bigint;
		stop : number | bigint;
		flags : Gst.BufferPoolAcquireFlags;

	}

	class BufferPoolClass {
		objectClass : Gst.ObjectClass;
		getOptions : (pool: Gst.BufferPool) => string[];
		setConfig : (pool: Gst.BufferPool, config: Gst.Structure) => boolean;
		start : (pool: Gst.BufferPool) => boolean;
		stop : (pool: Gst.BufferPool) => boolean;
		acquireBuffer : (pool: Gst.BufferPool, buffer: Gst.Buffer, params: Gst.BufferPoolAcquireParams | undefined | null) => Gst.FlowReturn;
		allocBuffer : (pool: Gst.BufferPool, buffer: Gst.Buffer, params: Gst.BufferPoolAcquireParams | undefined | null) => Gst.FlowReturn;
		resetBuffer : (pool: Gst.BufferPool, buffer: Gst.Buffer) => void;
		releaseBuffer : (pool: Gst.BufferPool, buffer: Gst.Buffer) => void;
		freeBuffer : (pool: Gst.BufferPool, buffer: Gst.Buffer) => void;
		flushStart : (pool: Gst.BufferPool) => void;
		flushStop : (pool: Gst.BufferPool) => void;

	}

	class BufferPoolPrivate {
	}

	class BusClass {
		parentClass : Gst.ObjectClass;
		message : (bus: Gst.Bus, message: Gst.Message) => void;
		syncMessage : (bus: Gst.Bus, message: Gst.Message) => void;

	}

	class BusPrivate {
	}

	class Caps {
		miniObject : Gst.MiniObject;

		static NewAny(): Gst.Caps;
		static NewEmpty(): Gst.Caps;
		static NewEmptySimple(mediaType: string): Gst.Caps;
		append(caps2: Gst.Caps): void;
		appendStructure(structure: Gst.Structure): void;
		appendStructureFull(structure: Gst.Structure, features: Gst.CapsFeatures | undefined | null): void;
		canIntersect(caps2: Gst.Caps): boolean;
		copy(): Gst.Caps;
		copyNth(nth: number): Gst.Caps;
		filterAndMapInPlace(func: (features: Gst.CapsFeatures, structure: Gst.Structure) => boolean): void;
		fixate(): Gst.Caps;
		foreach(func: (features: Gst.CapsFeatures, structure: Gst.Structure) => boolean): boolean;
		getFeatures(index: number): Gst.CapsFeatures;
		getSize(): number;
		getStructure(index: number): Gst.Structure;
		intersect(caps2: Gst.Caps): Gst.Caps;
		intersectFull(caps2: Gst.Caps, mode: Gst.CapsIntersectMode): Gst.Caps;
		isAlwaysCompatible(caps2: Gst.Caps): boolean;
		isAny(): boolean;
		isEmpty(): boolean;
		isEqual(caps2: Gst.Caps): boolean;
		isEqualFixed(caps2: Gst.Caps): boolean;
		isFixed(): boolean;
		isStrictlyEqual(caps2: Gst.Caps): boolean;
		isSubset(superset: Gst.Caps): boolean;
		isSubsetStructure(structure: Gst.Structure): boolean;
		isSubsetStructureFull(structure: Gst.Structure, features: Gst.CapsFeatures | undefined | null): boolean;
		mapInPlace(func: (features: Gst.CapsFeatures, structure: Gst.Structure) => boolean): boolean;
		merge(caps2: Gst.Caps): Gst.Caps;
		mergeStructure(structure: Gst.Structure): Gst.Caps;
		mergeStructureFull(structure: Gst.Structure, features: Gst.CapsFeatures | undefined | null): Gst.Caps;
		normalize(): Gst.Caps;
		removeStructure(idx: number): void;
		serialize(flags: Gst.SerializeFlags): string;
		setFeatures(index: number, features: Gst.CapsFeatures | undefined | null): void;
		setFeaturesSimple(features: Gst.CapsFeatures | undefined | null): void;
		setValue(field: string, value: GObject.Value): void;
		simplify(): Gst.Caps;
		stealStructure(index: number): Gst.Structure;
		subtract(subtrahend: Gst.Caps): Gst.Caps;
		truncate(): Gst.Caps;
		static FromString(string: string): Gst.Caps;
	}

	class CapsFeatures {
		static NewAny(): Gst.CapsFeatures;
		static NewEmpty(): Gst.CapsFeatures;
		static NewSingle(feature: string): Gst.CapsFeatures;
		add(feature: string): void;
		addId(feature: number): void;
		contains(feature: string): boolean;
		containsId(feature: number): boolean;
		copy(): Gst.CapsFeatures;
		free(): void;
		getNth(i: number): string;
		getNthId(i: number): number;
		getSize(): number;
		isAny(): boolean;
		isEqual(features2: Gst.CapsFeatures): boolean;
		remove(feature: string): void;
		removeId(feature: number): void;
		setParentRefcount(refcount: number): boolean;
		static FromString(features: string): Gst.CapsFeatures;
	}

	class ChildProxyInterface {
		parent : GObject.TypeInterface;
		getChildByName : (parent: Gst.ChildProxy, name: string) => GObject.Object;
		getChildByIndex : (parent: Gst.ChildProxy, index: number) => GObject.Object;
		getChildrenCount : (parent: Gst.ChildProxy) => number;
		childAdded : (parent: Gst.ChildProxy, child: GObject.Object, name: string) => void;
		childRemoved : (parent: Gst.ChildProxy, child: GObject.Object, name: string) => void;

	}

	class ClockClass {
		parentClass : Gst.ObjectClass;
		changeResolution : (clock: Gst.Clock, oldResolution: number | bigint, newResolution: number | bigint) => number | bigint;
		getResolution : (clock: Gst.Clock) => number | bigint;
		getInternalTime : (clock: Gst.Clock) => number | bigint;
		wait : (clock: Gst.Clock, entry: Gst.ClockEntry, jitter ?: number | bigint) => Gst.ClockReturn;
		waitAsync : (clock: Gst.Clock, entry: Gst.ClockEntry) => Gst.ClockReturn;
		unschedule : (clock: Gst.Clock, entry: Gst.ClockEntry) => void;

	}

	class ClockEntry {
		refcount : number;
		clock : Gst.Clock;
		type : Gst.ClockEntryType;
		time : number | bigint;
		interval : number | bigint;
		status : Gst.ClockReturn;
		func : (clock: Gst.Clock, time: number | bigint) => boolean;
		userData : void;
		destroyData : () => void;
		unscheduled : boolean;
		wokenUp : boolean;

	}

	class ClockPrivate {
	}

	class Context {
		static New(contextType: string, persistent: boolean): Gst.Context;
		getContextType(): string;
		getStructure(): Gst.Structure;
		hasContextType(contextType: string): boolean;
		isPersistent(): boolean;
		writableStructure(): Gst.Structure;
	}

	class ControlBindingClass {
		parentClass : Gst.ObjectClass;
		syncValues : (binding: Gst.ControlBinding, object: Gst.Object, timestamp: number | bigint, lastSync: number | bigint) => boolean;
		getValue : (binding: Gst.ControlBinding, timestamp: number | bigint) => GObject.Value;
		getValueArray : void;
		getGValueArray : (binding: Gst.ControlBinding, timestamp: number | bigint, interval: number | bigint, nValues: number, values: GObject.Value[]) => boolean;

	}

	class ControlBindingPrivate {
	}

	class ControlSourceClass {
		parentClass : Gst.ObjectClass;

	}

	class CustomMeta {
		meta : Gst.Meta;

		getStructure(): Gst.Structure;
		hasName(name: string): boolean;
	}

	class DateTime {
		static New(tzoffset: number, YEar: number, month: number, day: number, hour: number, minute: number, seconds: number): Gst.DateTime;
		static NewFromGDateTime(dt: AuGlibEx.DateTime | undefined | null): Gst.DateTime;
		static NewFromIso8601String(string: string): Gst.DateTime;
		static NewFromUnixEpochLocalTime(secs: number | bigint): Gst.DateTime;
		static NewFromUnixEpochLocalTimeUsecs(usecs: number | bigint): Gst.DateTime;
		static NewFromUnixEpochUtc(secs: number | bigint): Gst.DateTime;
		static NewFromUnixEpochUtcUsecs(usecs: number | bigint): Gst.DateTime;
		static NewLocalTime(YEar: number, month: number, day: number, hour: number, minute: number, seconds: number): Gst.DateTime;
		static NewNowLocalTime(): Gst.DateTime;
		static NewNowUtc(): Gst.DateTime;
		static NewY(YEar: number): Gst.DateTime;
		static NewYM(YEar: number, month: number): Gst.DateTime;
		static NewYMd(YEar: number, month: number, day: number): Gst.DateTime;
		getDay(): number;
		getHour(): number;
		getMicrosecond(): number;
		getMinute(): number;
		getMonth(): number;
		getSecond(): number;
		getTimeZoneOffset(): number;
		getYEar(): number;
		hasDay(): boolean;
		hasMonth(): boolean;
		hasSecond(): boolean;
		hasTime(): boolean;
		hasYEar(): boolean;
		ref(): Gst.DateTime;
		toGDateTime(): AuGlibEx.DateTime;
		toIso8601String(): string;
		unref(): void;
	}

	class DebugCategory {
		threshold : number;
		color : number;
		name : string;
		description : string;

		free(): void;
		getColor(): number;
		getDescription(): string;
		getName(): string;
		getThreshold(): Gst.DebugLevel;
		resetThreshold(): void;
		setThreshold(level: Gst.DebugLevel): void;
	}

	class DebugMessage {
		get(): string;
	}

	class DeviceClass {
		parentClass : Gst.ObjectClass;
		createElement : (device: Gst.Device, name: string | undefined | null) => Gst.Element;
		reconfigureElement : (device: Gst.Device, element: Gst.Element) => boolean;

	}

	class DeviceMonitorClass {
		parentClass : Gst.ObjectClass;

	}

	class DeviceMonitorPrivate {
	}

	class DevicePrivate {
	}

	class DeviceProviderClass {
		parentClass : Gst.ObjectClass;
		factory : Gst.DeviceProviderFactory;
		probe : void;
		start : (provider: Gst.DeviceProvider) => boolean;
		stop : (provider: Gst.DeviceProvider) => void;
		metadata : void;

		addMetadata(key: string, value: string): void;
		addStaticMetadata(key: string, value: string): void;
		getMetadata(key: string): string;
		setMetadata(longname: string, classification: string, description: string, author: string): void;
		setStaticMetadata(longname: string, classification: string, description: string, author: string): void;
	}

	class DeviceProviderFactoryClass {
	}

	class DeviceProviderPrivate {
	}

	class DynamicTypeFactoryClass {
	}

	class ElementClass {
		parentClass : Gst.ObjectClass;
		metadata : void;
		elementfactory : Gst.ElementFactory;
		numpadtemplates : number;
		padTemplCookie : number;
		padAdded : (element: Gst.Element, pad: Gst.Pad) => void;
		padRemoved : (element: Gst.Element, pad: Gst.Pad) => void;
		noMorePads : (element: Gst.Element) => void;
		requestNewPad : (element: Gst.Element, templ: Gst.PadTemplate, name: string | undefined | null, caps: Gst.Caps | undefined | null) => Gst.Pad;
		releasePad : (element: Gst.Element, pad: Gst.Pad) => void;
		getState : (element: Gst.Element, state ?: Gst.State, pending ?: Gst.State, timeout ?: number | bigint) => Gst.StateChangeReturn;
		setState : (element: Gst.Element, state: Gst.State) => Gst.StateChangeReturn;
		changeState : (element: Gst.Element, transition: Gst.StateChange) => Gst.StateChangeReturn;
		stateChanged : (element: Gst.Element, oldstate: Gst.State, newstate: Gst.State, pending: Gst.State) => void;
		setBus : (element: Gst.Element, bus: Gst.Bus | undefined | null) => void;
		provideClock : (element: Gst.Element) => Gst.Clock;
		setClock : (element: Gst.Element, clock: Gst.Clock | undefined | null) => boolean;
		sendEvent : (element: Gst.Element, event: Gst.Event) => boolean;
		query : (element: Gst.Element, query: Gst.Query) => boolean;
		postMessage : (element: Gst.Element, message: Gst.Message) => boolean;
		setContext : (element: Gst.Element, context: Gst.Context) => void;

		addMetadata(key: string, value: string): void;
		addPadTemplate(templ: Gst.PadTemplate): void;
		addStaticMetadata(key: string, value: string): void;
		addStaticPadTemplate(staticTempl: Gst.StaticPadTemplate): void;
		addStaticPadTemplateWithGtype(staticTempl: Gst.StaticPadTemplate, padType: number): void;
		getMetadata(key: string): string;
		getPadTemplate(name: string): Gst.PadTemplate;
		getPadTemplateList(): Gst.PadTemplate[];
		setMetadata(longname: string, classification: string, description: string, author: string): void;
		setStaticMetadata(longname: string, classification: string, description: string, author: string): void;
	}

	class ElementFactoryClass {
	}

	class Event {
		miniObject : Gst.MiniObject;
		type : Gst.EventType;
		timestamp : number | bigint;
		seqnum : number;

		static NewBufferSize(format: Gst.Format, minsize: number | bigint, maxsize: number | bigint, _async: boolean): Gst.Event;
		static NewCaps(caps: Gst.Caps): Gst.Event;
		static NewCustom(type: Gst.EventType, structure: Gst.Structure): Gst.Event;
		static NewEos(): Gst.Event;
		static NewFlushStart(): Gst.Event;
		static NewFlushStop(resetTime: boolean): Gst.Event;
		static NewGap(timestamp: number | bigint, duration: number | bigint): Gst.Event;
		static NewInstantRateChange(rateMultiplier: number, newFlags: Gst.SegmentFlags): Gst.Event;
		static NewInstantRateSyncTime(rateMultiplier: number, runningTime: number | bigint, upstreamRunningTime: number | bigint): Gst.Event;
		static NewLatency(latency: number | bigint): Gst.Event;
		static NewNavigation(structure: Gst.Structure): Gst.Event;
		static NewProtection(systemId: string, data: Gst.Buffer, origin: string): Gst.Event;
		static NewQos(type: Gst.QOSType, proportion: number, diff: number | bigint, timestamp: number | bigint): Gst.Event;
		static NewReconfigure(): Gst.Event;
		static NewSeek(rate: number, format: Gst.Format, flags: Gst.SeekFlags, startType: Gst.SeekType, start: number | bigint, stopType: Gst.SeekType, stop: number | bigint): Gst.Event;
		static NewSegment(segment: Gst.Segment): Gst.Event;
		static NewSegmentDone(format: Gst.Format, position: number | bigint): Gst.Event;
		static NewSelectStreams(streams: string[]): Gst.Event;
		static NewSinkMessage(name: string, msg: Gst.Message): Gst.Event;
		static NewStep(format: Gst.Format, amount: number | bigint, rate: number, flush: boolean, intermediate: boolean): Gst.Event;
		static NewStreamCollection(collection: Gst.StreamCollection): Gst.Event;
		static NewStreamGroupDone(groupId: number): Gst.Event;
		static NewStreamStart(streamId: string): Gst.Event;
		static NewTag(taglist: Gst.TagList): Gst.Event;
		static NewToc(toc: Gst.Toc, updated: boolean): Gst.Event;
		static NewTocSelect(uid: string): Gst.Event;
		copySegment(segment: Gst.Segment): void;
		getRunningTimeOffset(): number | bigint;
		getSeqnum(): number;
		getStructure(): Gst.Structure;
		hasName(name: string): boolean;
		hasNameId(name: number): boolean;
		parseBufferSize(format: Gst.Format, minsize: number | bigint, maxsize: number | bigint, _async: boolean): void;
		parseCaps(caps: Gst.Caps): void;
		parseFlushStop(resetTime: boolean): void;
		parseGap(timestamp ?: number | bigint, duration ?: number | bigint): void;
		parseGapFlags(flags: Gst.GapFlags): void;
		parseGroupId(groupId: number): boolean;
		parseInstantRateChange(rateMultiplier ?: number, newFlags ?: Gst.SegmentFlags): void;
		parseInstantRateSyncTime(rateMultiplier ?: number, runningTime ?: number | bigint, upstreamRunningTime ?: number | bigint): void;
		parseLatency(latency: number | bigint): void;
		parseProtection(systemId ?: string, data ?: Gst.Buffer, origin ?: string): void;
		parseQos(type: Gst.QOSType, proportion: number, diff: number | bigint, timestamp: number | bigint): void;
		parseSeek(rate: number, format: Gst.Format, flags: Gst.SeekFlags, startType: Gst.SeekType, start: number | bigint, stopType: Gst.SeekType, stop: number | bigint): void;
		parseSeekTrickmodeInterval(interval: number | bigint): void;
		parseSegment(segment: Gst.Segment): void;
		parseSegmentDone(format ?: Gst.Format, position ?: number | bigint): void;
		parseSelectStreams(streams: string[]): void;
		parseSinkMessage(msg: Gst.Message): void;
		parseStep(format ?: Gst.Format, amount ?: number | bigint, rate ?: number, flush ?: boolean, intermediate ?: boolean): void;
		parseStream(stream: Gst.Stream): void;
		parseStreamCollection(collection: Gst.StreamCollection): void;
		parseStreamFlags(flags: Gst.StreamFlags): void;
		parseStreamGroupDone(groupId: number): void;
		parseStreamStart(streamId: string): void;
		parseTag(taglist: Gst.TagList): void;
		parseToc(toc: Gst.Toc, updated: boolean): void;
		parseTocSelect(uid ?: string): void;
		setGapFlags(flags: Gst.GapFlags): void;
		setGroupId(groupId: number): void;
		setRunningTimeOffset(offset: number | bigint): void;
		setSeekTrickmodeInterval(interval: number | bigint): void;
		setSeqnum(seqnum: number): void;
		setStream(stream: Gst.Stream): void;
		setStreamFlags(flags: Gst.StreamFlags): void;
		writableStructure(): Gst.Structure;
	}

	class FormatDefinition {
		value : Gst.Format;
		nick : string;
		description : string;
		quark : number;

	}

	class GhostPadClass {
		parentClass : Gst.ProxyPadClass;

	}

	class GhostPadPrivate {
	}

	class Iterator {
		copy : (it: Gst.Iterator, copy: Gst.Iterator) => void;
		next : (it: Gst.Iterator, result: GObject.Value) => Gst.IteratorResult;
		item : (it: Gst.Iterator, item: GObject.Value) => Gst.IteratorItem;
		resync : (it: Gst.Iterator) => void;
		free : (it: Gst.Iterator) => void;
		pushed : Gst.Iterator;
		type : number;
		cookie : number;
		masterCookie : number;
		size : number;

		static NewSingle(type: number, object: GObject.Value): Gst.Iterator;
		filter(func: () => number, userData: GObject.Value): Gst.Iterator;
		findCustom(func: () => number, elem: GObject.Value): boolean;
		fold(func: (item: GObject.Value, ret: GObject.Value) => boolean, ret: GObject.Value): Gst.IteratorResult;
		foreach(func: (item: GObject.Value) => void): Gst.IteratorResult;
		push(other: Gst.Iterator): void;
	}

	class MapInfo {
		memory : Gst.Memory;
		flags : Gst.MapFlags;
		data : number[];
		size : number | bigint;
		maxsize : number | bigint;

	}

	class Memory {
		miniObject : Gst.MiniObject;
		allocator : Gst.Allocator;
		parent : Gst.Memory;
		maxsize : number | bigint;
		align : number | bigint;
		offset : number | bigint;
		size : number | bigint;

		static NewWrapped(flags: Gst.MemoryFlags, data: number[], maxsize: number | bigint, offset: number | bigint, size: number | bigint, notify: () => void | undefined | null): Gst.Memory;
		copy(offset: number | bigint, size: number | bigint): Gst.Memory;
		getSizes(offset ?: number | bigint, maxsize ?: number | bigint): number | bigint;
		isSpan(mem2: Gst.Memory, offset: number | bigint): boolean;
		isType(memType: string): boolean;
		makeMapped(info: Gst.MapInfo, flags: Gst.MapFlags): Gst.Memory;
		map(info: Gst.MapInfo, flags: Gst.MapFlags): boolean;
		resize(offset: number | bigint, size: number | bigint): void;
		share(offset: number | bigint, size: number | bigint): Gst.Memory;
		unmap(info: Gst.MapInfo): void;
	}

	class Message {
		miniObject : Gst.MiniObject;
		type : Gst.MessageType;
		timestamp : number | bigint;
		src : Gst.Object;
		seqnum : number;
		cond : AuGlibEx.Cond;

		static NewApplication(src: Gst.Object | undefined | null, structure: Gst.Structure): Gst.Message;
		static NewAsyncDone(src: Gst.Object | undefined | null, runningTime: number | bigint): Gst.Message;
		static NewAsyncStart(src: Gst.Object | undefined | null): Gst.Message;
		static NewBuffering(src: Gst.Object | undefined | null, percent: number): Gst.Message;
		static NewClockLost(src: Gst.Object | undefined | null, clock: Gst.Clock): Gst.Message;
		static NewClockProvide(src: Gst.Object | undefined | null, clock: Gst.Clock, ready: boolean): Gst.Message;
		static NewCustom(type: Gst.MessageType, src: Gst.Object | undefined | null, structure: Gst.Structure | undefined | null): Gst.Message;
		static NewDeviceAdded(src: Gst.Object, device: Gst.Device): Gst.Message;
		static NewDeviceChanged(src: Gst.Object, device: Gst.Device, changedDevice: Gst.Device): Gst.Message;
		static NewDeviceRemoved(src: Gst.Object, device: Gst.Device): Gst.Message;
		static NewDurationChanged(src: Gst.Object | undefined | null): Gst.Message;
		static NewElement(src: Gst.Object | undefined | null, structure: Gst.Structure): Gst.Message;
		static NewEos(src: Gst.Object | undefined | null): Gst.Message;
		static NewError(src: Gst.Object | undefined | null, error: AuGlibEx.Error, debug: string): Gst.Message;
		static NewErrorWithDetails(src: Gst.Object | undefined | null, error: AuGlibEx.Error, debug: string, details: Gst.Structure | undefined | null): Gst.Message;
		static NewHaveContext(src: Gst.Object | undefined | null, context: Gst.Context): Gst.Message;
		static NewInfo(src: Gst.Object | undefined | null, error: AuGlibEx.Error, debug: string): Gst.Message;
		static NewInfoWithDetails(src: Gst.Object | undefined | null, error: AuGlibEx.Error, debug: string, details: Gst.Structure | undefined | null): Gst.Message;
		static NewInstantRateRequest(src: Gst.Object, rateMultiplier: number): Gst.Message;
		static NewLatency(src: Gst.Object | undefined | null): Gst.Message;
		static NewNeedContext(src: Gst.Object | undefined | null, contextType: string): Gst.Message;
		static NewNewClock(src: Gst.Object | undefined | null, clock: Gst.Clock): Gst.Message;
		static NewProgress(src: Gst.Object, type: Gst.ProgressType, code: string, text: string): Gst.Message;
		static NewPropertyNotify(src: Gst.Object, propertyName: string, val: GObject.Value | undefined | null): Gst.Message;
		static NewQos(src: Gst.Object, live: boolean, runningTime: number | bigint, streamTime: number | bigint, timestamp: number | bigint, duration: number | bigint): Gst.Message;
		static NewRedirect(src: Gst.Object, location: string, tagList: Gst.TagList | undefined | null, entryStruct: Gst.Structure | undefined | null): Gst.Message;
		static NewRequestState(src: Gst.Object | undefined | null, state: Gst.State): Gst.Message;
		static NewResetTime(src: Gst.Object | undefined | null, runningTime: number | bigint): Gst.Message;
		static NewSegmentDone(src: Gst.Object | undefined | null, format: Gst.Format, position: number | bigint): Gst.Message;
		static NewSegmentStart(src: Gst.Object | undefined | null, format: Gst.Format, position: number | bigint): Gst.Message;
		static NewStateChanged(src: Gst.Object | undefined | null, oldstate: Gst.State, newstate: Gst.State, pending: Gst.State): Gst.Message;
		static NewStateDirty(src: Gst.Object | undefined | null): Gst.Message;
		static NewStepDone(src: Gst.Object, format: Gst.Format, amount: number | bigint, rate: number, flush: boolean, intermediate: boolean, duration: number | bigint, eos: boolean): Gst.Message;
		static NewStepStart(src: Gst.Object, active: boolean, format: Gst.Format, amount: number | bigint, rate: number, flush: boolean, intermediate: boolean): Gst.Message;
		static NewStreamCollection(src: Gst.Object, collection: Gst.StreamCollection): Gst.Message;
		static NewStreamStart(src: Gst.Object | undefined | null): Gst.Message;
		static NewStreamStatus(src: Gst.Object, type: Gst.StreamStatusType, owner: Gst.Element): Gst.Message;
		static NewStreamsSelected(src: Gst.Object, collection: Gst.StreamCollection): Gst.Message;
		static NewStructureChange(src: Gst.Object | undefined | null, type: Gst.StructureChangeType, owner: Gst.Element, busy: boolean): Gst.Message;
		static NewTag(src: Gst.Object | undefined | null, tagList: Gst.TagList): Gst.Message;
		static NewToc(src: Gst.Object, toc: Gst.Toc, updated: boolean): Gst.Message;
		static NewWarning(src: Gst.Object | undefined | null, error: AuGlibEx.Error, debug: string): Gst.Message;
		static NewWarningWithDetails(src: Gst.Object | undefined | null, error: AuGlibEx.Error, debug: string, details: Gst.Structure | undefined | null): Gst.Message;
		addRedirectEntry(location: string, tagList: Gst.TagList | undefined | null, entryStruct: Gst.Structure | undefined | null): void;
		getNumRedirectEntries(): number | bigint;
		getSeqnum(): number;
		getStreamStatusObject(): GObject.Value;
		getStructure(): Gst.Structure;
		hasName(name: string): boolean;
		parseAsyncDone(runningTime ?: number | bigint): void;
		parseBuffering(percent ?: number): void;
		parseBufferingStats(mode ?: Gst.BufferingMode, avgIn ?: number, avgOut ?: number, bufferingLeft ?: number | bigint): void;
		parseClockLost(clock ?: Gst.Clock): void;
		parseClockProvide(clock ?: Gst.Clock, ready ?: boolean): void;
		parseContextType(contextType ?: string): boolean;
		parseDeviceAdded(device ?: Gst.Device): void;
		parseDeviceChanged(device ?: Gst.Device, changedDevice ?: Gst.Device): void;
		parseDeviceRemoved(device ?: Gst.Device): void;
		parseError(gerror ?: AuGlibEx.Error, debug ?: string): void;
		parseErrorDetails(structure: Gst.Structure): void;
		parseGroupId(groupId ?: number): boolean;
		parseHaveContext(context ?: Gst.Context): void;
		parseInfo(gerror ?: AuGlibEx.Error, debug ?: string): void;
		parseInfoDetails(structure: Gst.Structure): void;
		parseInstantRateRequest(rateMultiplier ?: number): void;
		parseNewClock(clock ?: Gst.Clock): void;
		parseProgress(type ?: Gst.ProgressType, code ?: string, text ?: string): void;
		parsePropertyNotify(object ?: Gst.Object, propertyName ?: string, propertyValue ?: GObject.Value): void;
		parseQos(live ?: boolean, runningTime ?: number | bigint, streamTime ?: number | bigint, timestamp ?: number | bigint, duration ?: number | bigint): void;
		parseQosStats(format ?: Gst.Format, processed ?: number | bigint, dropped ?: number | bigint): void;
		parseQosValues(jitter ?: number | bigint, proportion ?: number, quality ?: number): void;
		parseRedirectEntry(entryIndex: number | bigint, location ?: string, tagList ?: Gst.TagList, entryStruct ?: Gst.Structure): void;
		parseRequestState(state ?: Gst.State): void;
		parseResetTime(runningTime ?: number | bigint): void;
		parseSegmentDone(format ?: Gst.Format, position ?: number | bigint): void;
		parseSegmentStart(format ?: Gst.Format, position ?: number | bigint): void;
		parseStateChanged(oldstate ?: Gst.State, newstate ?: Gst.State, pending ?: Gst.State): void;
		parseStepDone(format ?: Gst.Format, amount ?: number | bigint, rate ?: number, flush ?: boolean, intermediate ?: boolean, duration ?: number | bigint, eos ?: boolean): void;
		parseStepStart(active ?: boolean, format ?: Gst.Format, amount ?: number | bigint, rate ?: number, flush ?: boolean, intermediate ?: boolean): void;
		parseStreamCollection(collection ?: Gst.StreamCollection): void;
		parseStreamStatus(type: Gst.StreamStatusType, owner: Gst.Element): void;
		parseStreamsSelected(collection ?: Gst.StreamCollection): void;
		parseStructureChange(type: Gst.StructureChangeType, owner ?: Gst.Element, busy ?: boolean): void;
		parseTag(tagList: Gst.TagList): void;
		parseToc(toc: Gst.Toc, updated: boolean): void;
		parseWarning(gerror ?: AuGlibEx.Error, debug ?: string): void;
		parseWarningDetails(structure: Gst.Structure): void;
		setBufferingStats(mode: Gst.BufferingMode, avgIn: number, avgOut: number, bufferingLeft: number | bigint): void;
		setGroupId(groupId: number): void;
		setQosStats(format: Gst.Format, processed: number | bigint, dropped: number | bigint): void;
		setQosValues(jitter: number | bigint, proportion: number, quality: number): void;
		setSeqnum(seqnum: number): void;
		setStreamStatusObject(object: GObject.Value): void;
		streamsSelectedAdd(stream: Gst.Stream): void;
		streamsSelectedGetSize(): number;
		streamsSelectedGetStream(idx: number): Gst.Stream;
		writableStructure(): Gst.Structure;
	}

	class Meta {
		flags : Gst.MetaFlags;
		info : Gst.MetaInfo;

		compareSeqnum(meta2: Gst.Meta): number;
		getSeqnum(): number | bigint;
		static ApiTypeGetTags(api: number): string[];
		static ApiTypeHasTag(api: number, tag: number): boolean;
		static ApiTypeRegister(api: string, tags: string[]): number;
		static GetInfo(impl: string): Gst.MetaInfo;
		static Register(api: number, impl: string, size: number | bigint, initFunc: (meta: Gst.Meta, buffer: Gst.Buffer) => boolean, freeFunc: (meta: Gst.Meta, buffer: Gst.Buffer) => void, transformFunc: (transbuf: Gst.Buffer, meta: Gst.Meta, buffer: Gst.Buffer, type: number) => boolean): Gst.MetaInfo;
		static RegisterCustom(name: string, tags: string[], transformFunc: (transbuf: Gst.Buffer, meta: Gst.CustomMeta, buffer: Gst.Buffer, type: number) => boolean | undefined | null, destroyData: () => void): Gst.MetaInfo;
	}

	class MetaInfo {
		api : number;
		type : number;
		size : number | bigint;
		initFunc : (meta: Gst.Meta, buffer: Gst.Buffer) => boolean;
		freeFunc : (meta: Gst.Meta, buffer: Gst.Buffer) => void;
		transformFunc : (transbuf: Gst.Buffer, meta: Gst.Meta, buffer: Gst.Buffer, type: number) => boolean;

		isCustom(): boolean;
	}

	class MetaTransformCopy {
		region : boolean;
		offset : number | bigint;
		size : number | bigint;

	}

	class MiniObject {
		type : number;
		refcount : number;
		lockstate : number;
		flags : number;
		copy : (obj: Gst.MiniObject) => Gst.MiniObject;
		dispose : (obj: Gst.MiniObject) => boolean;
		free : (obj: Gst.MiniObject) => void;
		privUint : number;
		privPointer : void;

		addParent(parent: Gst.MiniObject): void;
		getQdata(quark: number): void;
		isWritable(): boolean;
		lock(flags: Gst.LockFlags): boolean;
		removeParent(parent: Gst.MiniObject): void;
		setQdata(quark: number, destroy: () => void): void;
		stealQdata(quark: number): void;
		unlock(flags: Gst.LockFlags): void;
		static Replace(olddata ?: Gst.MiniObject | undefined | null, newdata ?: Gst.MiniObject | undefined | null): boolean;
		static Take(olddata: Gst.MiniObject, newdata: Gst.MiniObject): boolean;
	}

	class ObjectClass {
		parentClass : GObject.InitiallyUnownedClass;
		pathStringSeparator : string;
		deepNotify : (object: Gst.Object, orig: Gst.Object, pspec: GObject.ParamSpec) => void;

	}

	class PadClass {
		parentClass : Gst.ObjectClass;
		linked : (pad: Gst.Pad, peer: Gst.Pad) => void;
		unlinked : (pad: Gst.Pad, peer: Gst.Pad) => void;

	}

	class PadPrivate {
	}

	class PadProbeInfo {
		type : Gst.PadProbeType;
		id : number;
		data : void;
		offset : number | bigint;
		size : number;

		getBuffer(): Gst.Buffer;
		getBufferList(): Gst.BufferList;
		getEvent(): Gst.Event;
		getQuery(): Gst.Query;
	}

	class PadTemplateClass {
		parentClass : Gst.ObjectClass;
		padCreated : (templ: Gst.PadTemplate, pad: Gst.Pad) => void;

	}

	class ParamSpecArray {
		parentInstance : GObject.ParamSpec;
		elementSpec : GObject.ParamSpec;

	}

	class ParamSpecFraction {
		parentInstance : GObject.ParamSpec;
		minNum : number;
		minDen : number;
		maxNum : number;
		maxDen : number;
		defNum : number;
		defDen : number;

	}

	class ParentBufferMeta {
		parent : Gst.Meta;
		buffer : Gst.Buffer;

		static GetInfo(): Gst.MetaInfo;
	}

	class ParseContext {
		static New(): Gst.ParseContext;
		copy(): Gst.ParseContext;
		free(): void;
		getMissingElements(): string[];
	}

	class PipelineClass {
		parentClass : Gst.BinClass;

	}

	class PipelinePrivate {
	}

	class PluginClass {
	}

	class PluginDesc {
		majorVersion : number;
		minorVersion : number;
		name : string;
		description : string;
		pluginInit : (plugin: Gst.Plugin) => boolean;
		version : string;
		license : string;
		source : string;
		package : string;
		origin : string;
		releaseDatetime : string;

	}

	class PluginFeatureClass {
	}

	class Poll {
		addFd(fd: Gst.PollFD): boolean;
		fdCanRead(fd: Gst.PollFD): boolean;
		fdCanWrite(fd: Gst.PollFD): boolean;
		fdCtlPri(fd: Gst.PollFD, active: boolean): boolean;
		fdCtlRead(fd: Gst.PollFD, active: boolean): boolean;
		fdCtlWrite(fd: Gst.PollFD, active: boolean): boolean;
		fdHasClosed(fd: Gst.PollFD): boolean;
		fdHasError(fd: Gst.PollFD): boolean;
		fdHasPri(fd: Gst.PollFD): boolean;
		fdIgnored(fd: Gst.PollFD): void;
		free(): void;
		getReadGpollfd(fd: AuGlibEx.PollFD): void;
		readControl(): boolean;
		removeFd(fd: Gst.PollFD): boolean;
		restart(): void;
		setControllable(controllable: boolean): boolean;
		setFlushing(flushing: boolean): void;
		wait(timeout: number | bigint): number;
		writeControl(): boolean;
	}

	class PollFD {
		fd : number;
		idx : number;

		init(): void;
	}

	class PresetInterface {
		parent : GObject.TypeInterface;
		getPresetNames : (preset: Gst.Preset) => string[];
		getPropertyNames : (preset: Gst.Preset) => string[];
		loadPreset : (preset: Gst.Preset, name: string) => boolean;
		savePreset : (preset: Gst.Preset, name: string) => boolean;
		renamePreset : (preset: Gst.Preset, oldName: string, newName: string) => boolean;
		deletePreset : (preset: Gst.Preset, name: string) => boolean;
		setMeta : (preset: Gst.Preset, name: string, tag: string, value: string | undefined | null) => boolean;
		getMeta : (preset: Gst.Preset, name: string, tag: string, value: string) => boolean;

	}

	class Promise {
		parent : Gst.MiniObject;

		static New(): Gst.Promise;
		static NewWithChangeFunc(func: (promise: Gst.Promise) => void, notify: () => void): Gst.Promise;
		expire(): void;
		getReply(): Gst.Structure;
		interrupt(): void;
		reply(s: Gst.Structure | undefined | null): void;
		wait(): Gst.PromiseResult;
	}

	class ProtectionMeta {
		meta : Gst.Meta;
		info : Gst.Structure;

		static GetInfo(): Gst.MetaInfo;
	}

	class ProxyPadClass {
		parentClass : Gst.PadClass;

	}

	class ProxyPadPrivate {
	}

	class Query {
		miniObject : Gst.MiniObject;
		type : Gst.QueryType;

		static NewAcceptCaps(caps: Gst.Caps): Gst.Query;
		static NewAllocation(caps: Gst.Caps, needPool: boolean): Gst.Query;
		static NewBitrate(): Gst.Query;
		static NewBuffering(format: Gst.Format): Gst.Query;
		static NewCaps(filter: Gst.Caps): Gst.Query;
		static NewContext(contextType: string): Gst.Query;
		static NewConvert(srcFormat: Gst.Format, value: number | bigint, destFormat: Gst.Format): Gst.Query;
		static NewCustom(type: Gst.QueryType, structure: Gst.Structure | undefined | null): Gst.Query;
		static NewDrain(): Gst.Query;
		static NewDuration(format: Gst.Format): Gst.Query;
		static NewFormats(): Gst.Query;
		static NewLatency(): Gst.Query;
		static NewPosition(format: Gst.Format): Gst.Query;
		static NewScheduling(): Gst.Query;
		static NewSeeking(format: Gst.Format): Gst.Query;
		static NewSegment(format: Gst.Format): Gst.Query;
		static NewUri(): Gst.Query;
		addAllocationMeta(api: number, params: Gst.Structure | undefined | null): void;
		addAllocationParam(allocator: Gst.Allocator | undefined | null, params: Gst.AllocationParams | undefined | null): void;
		addAllocationPool(pool: Gst.BufferPool | undefined | null, size: number, minBuffers: number, maxBuffers: number): void;
		addBufferingRange(start: number | bigint, stop: number | bigint): boolean;
		addSchedulingMode(mode: Gst.PadMode): void;
		findAllocationMeta(api: number, index ?: number): boolean;
		getNAllocationMetas(): number;
		getNAllocationParams(): number;
		getNAllocationPools(): number;
		getNBufferingRanges(): number;
		getNSchedulingModes(): number;
		getStructure(): Gst.Structure;
		hasSchedulingMode(mode: Gst.PadMode): boolean;
		hasSchedulingModeWithFlags(mode: Gst.PadMode, flags: Gst.SchedulingFlags): boolean;
		parseAcceptCaps(caps: Gst.Caps): void;
		parseAcceptCapsResult(result ?: boolean): void;
		parseAllocation(caps ?: Gst.Caps, needPool ?: boolean): void;
		parseBitrate(nominalBitrate ?: number): void;
		parseBufferingPercent(busy ?: boolean, percent ?: number): void;
		parseBufferingRange(format ?: Gst.Format, start ?: number | bigint, stop ?: number | bigint, estimatedTotal ?: number | bigint): void;
		parseBufferingStats(mode ?: Gst.BufferingMode, avgIn ?: number, avgOut ?: number, bufferingLeft ?: number | bigint): void;
		parseCaps(filter: Gst.Caps): void;
		parseCapsResult(caps: Gst.Caps): void;
		parseContext(context: Gst.Context): void;
		parseContextType(contextType ?: string): boolean;
		parseConvert(srcFormat ?: Gst.Format, srcValue ?: number | bigint, destFormat ?: Gst.Format, destValue ?: number | bigint): void;
		parseDuration(format ?: Gst.Format, duration ?: number | bigint): void;
		parseLatency(live ?: boolean, minLatency ?: number | bigint, maxLatency ?: number | bigint): void;
		parseNFormats(nFormats ?: number): void;
		parseNthAllocationMeta(index: number, params ?: Gst.Structure): number;
		parseNthAllocationParam(index: number, allocator ?: Gst.Allocator, params ?: Gst.AllocationParams): void;
		parseNthAllocationPool(index: number, pool ?: Gst.BufferPool, size ?: number, minBuffers ?: number, maxBuffers ?: number): void;
		parseNthBufferingRange(index: number, start ?: number | bigint, stop ?: number | bigint): boolean;
		parseNthFormat(nth: number, format ?: Gst.Format): void;
		parseNthSchedulingMode(index: number): Gst.PadMode;
		parsePosition(format ?: Gst.Format, cur ?: number | bigint): void;
		parseScheduling(flags ?: Gst.SchedulingFlags, minsize ?: number, maxsize ?: number, align ?: number): void;
		parseSeeking(format ?: Gst.Format, seekable ?: boolean, segmentStart ?: number | bigint, segmentEnd ?: number | bigint): void;
		parseSegment(rate ?: number, format ?: Gst.Format, startValue ?: number | bigint, stopValue ?: number | bigint): void;
		parseUri(uri ?: string): void;
		parseUriRedirection(uri ?: string): void;
		parseUriRedirectionPermanent(permanent ?: boolean): void;
		removeNthAllocationMeta(index: number): void;
		removeNthAllocationParam(index: number): void;
		removeNthAllocationPool(index: number): void;
		setAcceptCapsResult(result: boolean): void;
		setBitrate(nominalBitrate: number): void;
		setBufferingPercent(busy: boolean, percent: number): void;
		setBufferingRange(format: Gst.Format, start: number | bigint, stop: number | bigint, estimatedTotal: number | bigint): void;
		setBufferingStats(mode: Gst.BufferingMode, avgIn: number, avgOut: number, bufferingLeft: number | bigint): void;
		setCapsResult(caps: Gst.Caps): void;
		setContext(context: Gst.Context): void;
		setConvert(srcFormat: Gst.Format, srcValue: number | bigint, destFormat: Gst.Format, destValue: number | bigint): void;
		setDuration(format: Gst.Format, duration: number | bigint): void;
		setFormatsv(nFormats: number, formats: Gst.Format[]): void;
		setLatency(live: boolean, minLatency: number | bigint, maxLatency: number | bigint): void;
		setNthAllocationParam(index: number, allocator: Gst.Allocator | undefined | null, params: Gst.AllocationParams | undefined | null): void;
		setNthAllocationPool(index: number, pool: Gst.BufferPool | undefined | null, size: number, minBuffers: number, maxBuffers: number): void;
		setPosition(format: Gst.Format, cur: number | bigint): void;
		setScheduling(flags: Gst.SchedulingFlags, minsize: number, maxsize: number, align: number): void;
		setSeeking(format: Gst.Format, seekable: boolean, segmentStart: number | bigint, segmentEnd: number | bigint): void;
		setSegment(rate: number, format: Gst.Format, startValue: number | bigint, stopValue: number | bigint): void;
		setUri(uri: string): void;
		setUriRedirection(uri: string): void;
		setUriRedirectionPermanent(permanent: boolean): void;
		writableStructure(): Gst.Structure;
	}

	class ReferenceTimestampMeta {
		parent : Gst.Meta;
		reference : Gst.Caps;
		timestamp : number | bigint;
		duration : number | bigint;

		static GetInfo(): Gst.MetaInfo;
	}

	class RegistryClass {
		parentClass : Gst.ObjectClass;

	}

	class RegistryPrivate {
	}

	class Sample {
		static New(buffer: Gst.Buffer | undefined | null, caps: Gst.Caps | undefined | null, segment: Gst.Segment | undefined | null, info: Gst.Structure | undefined | null): Gst.Sample;
		getBuffer(): Gst.Buffer;
		getBufferList(): Gst.BufferList;
		getCaps(): Gst.Caps;
		getInfo(): Gst.Structure;
		getSegment(): Gst.Segment;
		setBuffer(buffer: Gst.Buffer): void;
		setBufferList(bufferList: Gst.BufferList): void;
		setCaps(caps: Gst.Caps): void;
		setInfo(info: Gst.Structure): boolean;
		setSegment(segment: Gst.Segment): void;
	}

	class Segment {
		flags : Gst.SegmentFlags;
		rate : number;
		appliedRate : number;
		format : Gst.Format;
		base : number | bigint;
		offset : number | bigint;
		start : number | bigint;
		stop : number | bigint;
		time : number | bigint;
		position : number | bigint;
		duration : number | bigint;

		static New(): Gst.Segment;
		clip(format: Gst.Format, start: number | bigint, stop: number | bigint, clipStart ?: number | bigint, clipStop ?: number | bigint): boolean;
		copy(): Gst.Segment;
		copyInto(dest: Gst.Segment): void;
		doSeek(rate: number, format: Gst.Format, flags: Gst.SeekFlags, startType: Gst.SeekType, start: number | bigint, stopType: Gst.SeekType, stop: number | bigint, update ?: boolean): boolean;
		free(): void;
		init(format: Gst.Format): void;
		isEqual(s1: Gst.Segment): boolean;
		offsetRunningTime(format: Gst.Format, offset: number | bigint): boolean;
		positionFromRunningTime(format: Gst.Format, runningTime: number | bigint): number | bigint;
		positionFromRunningTimeFull(format: Gst.Format, runningTime: number | bigint, position: number | bigint): number;
		positionFromStreamTime(format: Gst.Format, streamTime: number | bigint): number | bigint;
		positionFromStreamTimeFull(format: Gst.Format, streamTime: number | bigint, position: number | bigint): number;
		setRunningTime(format: Gst.Format, runningTime: number | bigint): boolean;
		toPosition(format: Gst.Format, runningTime: number | bigint): number | bigint;
		toRunningTime(format: Gst.Format, position: number | bigint): number | bigint;
		toRunningTimeFull(format: Gst.Format, position: number | bigint, runningTime ?: number | bigint): number;
		toStreamTime(format: Gst.Format, position: number | bigint): number | bigint;
		toStreamTimeFull(format: Gst.Format, position: number | bigint, streamTime: number | bigint): number;
	}

	class SharedTaskPoolClass {
		parentClass : Gst.TaskPoolClass;

	}

	class SharedTaskPoolPrivate {
	}

	class StaticCaps {
		caps : Gst.Caps;
		string : string;

		cleanup(): void;
		get(): Gst.Caps;
	}

	class StaticPadTemplate {
		nameTemplate : string;
		direction : Gst.PadDirection;
		presence : Gst.PadPresence;
		staticCaps : Gst.StaticCaps;

		get(): Gst.PadTemplate;
		getCaps(): Gst.Caps;
	}

	class StreamClass {
		parentClass : Gst.ObjectClass;

	}

	class StreamCollectionClass {
		parentClass : Gst.ObjectClass;
		streamNotify : (collection: Gst.StreamCollection, stream: Gst.Stream, pspec: GObject.ParamSpec) => void;

	}

	class StreamCollectionPrivate {
	}

	class StreamPrivate {
	}

	class Structure {
		type : number;
		name : number;

		static FromString(string: string, end ?: string): Gst.Structure;
		static NewEmpty(name: string): Gst.Structure;
		static NewFromString(string: string): Gst.Structure;
		static NewIdEmpty(quark: number): Gst.Structure;
		canIntersect(struct2: Gst.Structure): boolean;
		copy(): Gst.Structure;
		filterAndMapInPlace(func: (fieldId: number, value: GObject.Value) => boolean): void;
		fixate(): void;
		fixateField(fieldName: string): boolean;
		fixateFieldBoolean(fieldName: string, target: boolean): boolean;
		fixateFieldNearestDouble(fieldName: string, target: number): boolean;
		fixateFieldNearestFraction(fieldName: string, targetNumerator: number, targetDenominator: number): boolean;
		fixateFieldNearestInt(fieldName: string, target: number): boolean;
		fixateFieldString(fieldName: string, target: string): boolean;
		foreach(func: (fieldId: number, value: GObject.Value) => boolean): boolean;
		free(): void;
		getArray(fieldname: string, array: GObject.ValueArray): boolean;
		getBoolean(fieldname: string, value: boolean): boolean;
		getClockTime(fieldname: string, value: number | bigint): boolean;
		getDate(fieldname: string, value: AuGlibEx.Date): boolean;
		getDateTime(fieldname: string, value: Gst.DateTime): boolean;
		getDouble(fieldname: string, value: number): boolean;
		getEnum(fieldname: string, enumtype: number, value: number): boolean;
		getFieldType(fieldname: string): number;
		getFlagset(fieldname: string, valueFlags ?: number, valueMask ?: number): boolean;
		getFraction(fieldname: string, valueNumerator: number, valueDenominator: number): boolean;
		getInt(fieldname: string, value: number): boolean;
		getInt64(fieldname: string, value: number | bigint): boolean;
		getList(fieldname: string, array: GObject.ValueArray): boolean;
		getName(): string;
		getNameId(): number;
		getString(fieldname: string): string;
		getUint(fieldname: string, value: number): boolean;
		getUint64(fieldname: string, value: number | bigint): boolean;
		getValue(fieldname: string): GObject.Value;
		hasField(fieldname: string): boolean;
		hasFieldTyped(fieldname: string, type: number): boolean;
		hasName(name: string): boolean;
		idGetValue(field: number): GObject.Value;
		idHasField(field: number): boolean;
		idHasFieldTyped(field: number, type: number): boolean;
		idSetValue(field: number, value: GObject.Value): void;
		idTakeValue(field: number, value: GObject.Value): void;
		intersect(struct2: Gst.Structure): Gst.Structure;
		isEqual(structure2: Gst.Structure): boolean;
		isSubset(superset: Gst.Structure): boolean;
		mapInPlace(func: (fieldId: number, value: GObject.Value) => boolean): boolean;
		nFields(): number;
		nthFieldName(index: number): string;
		removeAllFields(): void;
		removeField(fieldname: string): void;
		serialize(flags: Gst.SerializeFlags): string;
		setArray(fieldname: string, array: GObject.ValueArray): void;
		setList(fieldname: string, array: GObject.ValueArray): void;
		setName(name: string): void;
		setParentRefcount(refcount: number): boolean;
		setValue(fieldname: string, value: GObject.Value): void;
		takeValue(fieldname: string, value: GObject.Value): void;
		static Take(oldstrPtr ?: Gst.Structure | undefined | null, newstr ?: Gst.Structure | undefined | null): boolean;
	}

	class SystemClockClass {
		parentClass : Gst.ClockClass;

	}

	class SystemClockPrivate {
	}

	class TagList {
		miniObject : Gst.MiniObject;

		static NewEmpty(): Gst.TagList;
		static NewFromString(str: string): Gst.TagList;
		addValue(mode: Gst.TagMergeMode, tag: string, value: GObject.Value): void;
		copy(): Gst.TagList;
		foreach(func: (list: Gst.TagList, tag: string) => void): void;
		getBoolean(tag: string, value: boolean): boolean;
		getBooleanIndex(tag: string, index: number, value: boolean): boolean;
		getDate(tag: string, value: AuGlibEx.Date): boolean;
		getDateIndex(tag: string, index: number, value: AuGlibEx.Date): boolean;
		getDateTime(tag: string, value: Gst.DateTime): boolean;
		getDateTimeIndex(tag: string, index: number, value: Gst.DateTime): boolean;
		getDouble(tag: string, value: number): boolean;
		getDoubleIndex(tag: string, index: number, value: number): boolean;
		getFloat(tag: string, value: number): boolean;
		getFloatIndex(tag: string, index: number, value: number): boolean;
		getInt(tag: string, value: number): boolean;
		getInt64(tag: string, value: number | bigint): boolean;
		getInt64Index(tag: string, index: number, value: number | bigint): boolean;
		getIntIndex(tag: string, index: number, value: number): boolean;
		getPointer(tag: string): boolean;
		getPointerIndex(tag: string, index: number): boolean;
		getSample(tag: string, sample: Gst.Sample): boolean;
		getSampleIndex(tag: string, index: number, sample: Gst.Sample): boolean;
		getScope(): Gst.TagScope;
		getString(tag: string, value: string): boolean;
		getStringIndex(tag: string, index: number, value: string): boolean;
		getTagSize(tag: string): number;
		getUint(tag: string, value: number): boolean;
		getUint64(tag: string, value: number | bigint): boolean;
		getUint64Index(tag: string, index: number, value: number | bigint): boolean;
		getUintIndex(tag: string, index: number, value: number): boolean;
		getValueIndex(tag: string, index: number): GObject.Value;
		insert(from: Gst.TagList, mode: Gst.TagMergeMode): void;
		isEmpty(): boolean;
		isEqual(list2: Gst.TagList): boolean;
		merge(list2: Gst.TagList | undefined | null, mode: Gst.TagMergeMode): Gst.TagList;
		nTags(): number;
		nthTagName(index: number): string;
		peekStringIndex(tag: string, index: number, value: string): boolean;
		removeTag(tag: string): void;
		setScope(scope: Gst.TagScope): void;
		static CopyValue(dest: GObject.Value, list: Gst.TagList, tag: string): boolean;
	}

	class TagSetterInterface {
		gIface : GObject.TypeInterface;

	}

	class TaskClass {
		parentClass : Gst.ObjectClass;
		pool : Gst.TaskPool;

	}

	class TaskPoolClass {
		parentClass : Gst.ObjectClass;
		prepare : (pool: Gst.TaskPool) => void;
		cleanup : (pool: Gst.TaskPool) => void;
		push : (pool: Gst.TaskPool, func: () => void) => void;
		join : (pool: Gst.TaskPool) => void;
		disposeHandle : (pool: Gst.TaskPool) => void;

	}

	class TaskPrivate {
	}

	class TimedValue {
		timestamp : number | bigint;
		value : number;

	}

	class Toc {
		static New(scope: Gst.TocScope): Gst.Toc;
		appendEntry(entry: Gst.TocEntry): void;
		dump(): void;
		findEntry(uid: string): Gst.TocEntry;
		getEntries(): Gst.TocEntry[];
		getScope(): Gst.TocScope;
		getTags(): Gst.TagList;
		mergeTags(tags: Gst.TagList | undefined | null, mode: Gst.TagMergeMode): void;
		setTags(tags: Gst.TagList | undefined | null): void;
	}

	class TocEntry {
		static New(type: Gst.TocEntryType, uid: string): Gst.TocEntry;
		appendSubEntry(subentry: Gst.TocEntry): void;
		getEntryType(): Gst.TocEntryType;
		getLoop(loopType ?: Gst.TocLoopType, repeatCount ?: number): boolean;
		getParent(): Gst.TocEntry;
		getStartStopTimes(start ?: number | bigint, stop ?: number | bigint): boolean;
		getSubEntries(): Gst.TocEntry[];
		getTags(): Gst.TagList;
		getToc(): Gst.Toc;
		getUid(): string;
		isAlternative(): boolean;
		isSequence(): boolean;
		mergeTags(tags: Gst.TagList | undefined | null, mode: Gst.TagMergeMode): void;
		setLoop(loopType: Gst.TocLoopType, repeatCount: number): void;
		setStartStopTimes(start: number | bigint, stop: number | bigint): void;
		setTags(tags: Gst.TagList | undefined | null): void;
	}

	class TocSetterInterface {
		gIface : GObject.TypeInterface;

	}

	class TracerClass {
		parentClass : Gst.ObjectClass;

	}

	class TracerFactoryClass {
	}

	class TracerPrivate {
	}

	class TracerRecordClass {
	}

	class TypeFind {
		peek : (offset: number | bigint, size: number) => number;
		suggest : (probability: number, caps: Gst.Caps) => void;
		data : void;
		getLength : () => number | bigint;

		suggestEmptySimple(probability: number, mediaType: string): void;
		static Register(plugin: Gst.Plugin | undefined | null, name: string, rank: number, func: (find: Gst.TypeFind) => void, extensions: string | undefined | null, possibleCaps: Gst.Caps | undefined | null, dataNotify: () => void): boolean;
	}

	class TypeFindFactoryClass {
	}

	class URIHandlerInterface {
		parent : GObject.TypeInterface;
		getType : (type: number) => Gst.URIType;
		getProtocols : (type: number) => string[];
		getUri : (handler: Gst.URIHandler) => string;
		setUri : (handler: Gst.URIHandler, uri: string) => boolean;

	}

	class Uri {
		static New(scheme: string | undefined | null, userinfo: string | undefined | null, host: string | undefined | null, port: number, path: string | undefined | null, query: string | undefined | null, fragment: string | undefined | null): Gst.Uri;
		appendPath(relativePath: string): boolean;
		appendPathSegment(pathSegment: string): boolean;
		equal(second: Gst.Uri): boolean;
		fromStringWithBase(uri: string): Gst.Uri;
		getFragment(): string;
		getHost(): string;
		getMediaFragmentTable(): number;
		getPath(): string;
		getPathSegments(): string[];
		getPathString(): string;
		getPort(): number;
		getQueryKeys(): string[];
		getQueryString(): string;
		getQueryTable(): number;
		getQueryValue(queryKey: string): string;
		getScheme(): string;
		getUserinfo(): string;
		isNormalized(): boolean;
		isWritable(): boolean;
		join(refUri: Gst.Uri | undefined | null): Gst.Uri;
		makeWritable(): Gst.Uri;
		newWithBase(scheme: string | undefined | null, userinfo: string | undefined | null, host: string | undefined | null, port: number, path: string | undefined | null, query: string | undefined | null, fragment: string | undefined | null): Gst.Uri;
		normalize(): boolean;
		queryHasKey(queryKey: string): boolean;
		removeQueryKey(queryKey: string): boolean;
		setFragment(fragment: string | undefined | null): boolean;
		setHost(host: string): boolean;
		setPath(path: string): boolean;
		setPathSegments(pathSegments: string[] | undefined | null): boolean;
		setPathString(path: string): boolean;
		setPort(port: number): boolean;
		setQueryString(query: string): boolean;
		setQueryTable(queryTable: number | undefined | null): boolean;
		setQueryValue(queryKey: string, queryValue: string | undefined | null): boolean;
		setScheme(scheme: string): boolean;
		setUserinfo(userinfo: string): boolean;
		static Construct(protocol: string, location: string): string;
		static FromString(uri: string): Gst.Uri;
		static FromStringEscaped(uri: string): Gst.Uri;
		static GetLocation(uri: string): string;
		static GetProtocol(uri: string): string;
		static HasProtocol(uri: string, protocol: string): boolean;
		static IsValid(uri: string): boolean;
		static JoinStrings(baseUri: string, refUri: string): string;
		static ProtocolIsSupported(type: Gst.URIType, protocol: string): boolean;
		static ProtocolIsValid(protocol: string): boolean;
	}

	class ValueTable {
		type : number;
		compare : (value1: GObject.Value, value2: GObject.Value) => number;
		serialize : (value1: GObject.Value) => string;
		deserialize : (dest: GObject.Value, s: string) => boolean;
		deserializeWithPspec : (dest: GObject.Value, s: string, pspec: GObject.ParamSpec) => boolean;

	}


	class Allocator extends Gst.Object {
		constructor(initializerList ?: AllocatorCtor);

		object : Gst.Object;
		memType : string;
		memMap : (mem: Gst.Memory, maxsize: number | bigint, flags: Gst.MapFlags) => void;
		memUnmap : (mem: Gst.Memory) => void;
		memCopy : (mem: Gst.Memory, offset: number | bigint, size: number | bigint) => Gst.Memory;
		memShare : (mem: Gst.Memory, offset: number | bigint, size: number | bigint) => Gst.Memory;
		memIsSpan : (mem1: Gst.Memory, mem2: Gst.Memory, offset: number | bigint) => boolean;
		memMapFull : (mem: Gst.Memory, info: Gst.MapInfo, maxsize: number | bigint) => void;
		memUnmapFull : (mem: Gst.Memory, info: Gst.MapInfo) => void;
		priv : Gst.AllocatorPrivate;

		static Find(name: string | undefined | null): Gst.Allocator;
		static Register(name: string, allocator: Gst.Allocator): void;
		alloc(size: number | bigint, params: Gst.AllocationParams | undefined | null): Gst.Memory;
		free(memory: Gst.Memory): void;
		setDefault(): void;
		//TypeScript is complete garbage: 
	}

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

	class Bin extends Gst.Element implements Gst.ChildProxy {
		constructor(initializerList ?: BinCtor);

		element : Gst.Element;
		numchildren : number;
		children : Gst.Element[];
		childrenCookie : number;
		childBus : Gst.Bus;
		messages : Gst.Message[];
		polling : boolean;
		stateDirty : boolean;
		clockDirty : boolean;
		providedClock : Gst.Clock;
		clockProvider : Gst.Element;
		priv : Gst.BinPrivate;

		asyncHandling : boolean;
		messageForward : boolean;

		static New(name: string | undefined | null): Gst.Element;
		add(element: Gst.Element): boolean;
		findUnlinkedPad(direction: Gst.PadDirection): Gst.Pad;
		getByInterface(iface: number): Gst.Element;
		getByName(name: string): Gst.Element;
		getByNameRecurseUp(name: string): Gst.Element;
		getSuppressedFlags(): Gst.ElementFlags;
		iterateAllByElementFactoryName(factoryName: string): Gst.Iterator;
		iterateAllByInterface(iface: number): Gst.Iterator;
		iterateElements(): Gst.Iterator;
		iterateRecurse(): Gst.Iterator;
		iterateSinks(): Gst.Iterator;
		iterateSorted(): Gst.Iterator;
		iterateSources(): Gst.Iterator;
		recalculateLatency(): boolean;
		remove(element: Gst.Element): boolean;
		setSuppressedFlags(flags: Gst.ElementFlags): void;
		syncChildrenStates(): boolean;
		//TypeScript is complete garbage: 
		childAdded(child: GObject.Object, name: string): void;
		childRemoved(child: GObject.Object, name: string): void;
		getChildByIndex(index: number): GObject.Object;
		getChildByName(name: string): GObject.Object;
		getChildrenCount(): number;
		lookup(name: string, target ?: GObject.Object, pspec ?: GObject.ParamSpec): boolean;
	}

	class BinCtor {
		name ?: string;
		parent ?: Gst.Object;
		asyncHandling ?: boolean;
		messageForward ?: boolean;
	}

	class BinEventListener extends AuGlibEx.IEventListener {
		deepElementAdded(subBin: Gst.Bin, element: Gst.Element): void;
		deepElementRemoved(subBin: Gst.Bin, element: Gst.Element): void;
		doLatency(): boolean;
		elementAdded(element: Gst.Element): void;
		elementRemoved(element: Gst.Element): void;
	}

	class Bitmask {
		constructor(initializerList ?: BitmaskCtor);

		//TypeScript is complete garbage: 
	}

	class BitmaskCtor {
	}

	class BufferPool extends Gst.Object {
		constructor(initializerList ?: BufferPoolCtor);

		object : Gst.Object;
		flushing : number;
		priv : Gst.BufferPoolPrivate;

		static New(): Gst.BufferPool;
		static ConfigAddOption(config: Gst.Structure, option: string): void;
		static ConfigGetAllocator(config: Gst.Structure, allocator ?: Gst.Allocator | undefined | null, params ?: Gst.AllocationParams): boolean;
		static ConfigGetOption(config: Gst.Structure, index: number): string;
		static ConfigGetParams(config: Gst.Structure, caps ?: Gst.Caps | undefined | null, size ?: number, minBuffers ?: number, maxBuffers ?: number): boolean;
		static ConfigHasOption(config: Gst.Structure, option: string): boolean;
		static ConfigNOptions(config: Gst.Structure): number;
		static ConfigSetAllocator(config: Gst.Structure, allocator: Gst.Allocator | undefined | null, params: Gst.AllocationParams | undefined | null): void;
		static ConfigSetParams(config: Gst.Structure, caps: Gst.Caps | undefined | null, size: number, minBuffers: number, maxBuffers: number): void;
		static ConfigValidateParams(config: Gst.Structure, caps: Gst.Caps | undefined | null, size: number, minBuffers: number, maxBuffers: number): boolean;
		acquireBuffer(buffer: Gst.Buffer, params: Gst.BufferPoolAcquireParams | undefined | null): Gst.FlowReturn;
		getConfig(): Gst.Structure;
		getOptions(): string[];
		hasOption(option: string): boolean;
		isActive(): boolean;
		releaseBuffer(buffer: Gst.Buffer): void;
		setActive(active: boolean): boolean;
		setConfig(config: Gst.Structure): boolean;
		setFlushing(flushing: boolean): void;
		//TypeScript is complete garbage: 
	}

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

	class Bus extends Gst.Object {
		constructor(initializerList ?: BusCtor);

		object : Gst.Object;
		priv : Gst.BusPrivate;

		enableAsync : boolean;

		static New(): Gst.Bus;
		addSignalWatch(): void;
		addSignalWatchFull(priority: number): void;
		addWatch(priority: number, func: (bus: Gst.Bus, message: Gst.Message) => boolean, notify: () => void): number;
		asyncSignalFunc(message: Gst.Message): boolean;
		createWatch(): AuGlibEx.Source;
		disableSyncMessageEmission(): void;
		enableSyncMessageEmission(): void;
		getPollfd(fd: AuGlibEx.PollFD): void;
		havePending(): boolean;
		peek(): Gst.Message;
		poll(events: Gst.MessageType, timeout: number | bigint): Gst.Message;
		pop(): Gst.Message;
		popFiltered(types: Gst.MessageType): Gst.Message;
		post(message: Gst.Message): boolean;
		removeSignalWatch(): void;
		removeWatch(): boolean;
		setFlushing(flushing: boolean): void;
		setSyncHandler(func: (bus: Gst.Bus, message: Gst.Message) => Gst.BusSyncReply | undefined | null, notify: () => void): void;
		syncSignalHandler(message: Gst.Message): Gst.BusSyncReply;
		timedPop(timeout: number | bigint): Gst.Message;
		timedPopFiltered(timeout: number | bigint, types: Gst.MessageType): Gst.Message;
		//TypeScript is complete garbage: 
	}

	class BusCtor {
		name ?: string;
		parent ?: Gst.Object;
		enableAsync ?: boolean;
	}

	class BusEventListener extends AuGlibEx.IEventListener {
		message(message: Gst.Message): void;
		syncMessage(message: Gst.Message): void;
	}

	class Clock extends Gst.Object {
		constructor(initializerList ?: ClockCtor);

		object : Gst.Object;
		priv : Gst.ClockPrivate;

		timeout : number | bigint;
		windowSize : number;
		windowThreshold : number;

		static IdCompareFunc(): number;
		static IdGetClock(): Gst.Clock;
		static IdGetTime(): number | bigint;
		static IdRef(): void;
		static IdUnref(): void;
		static IdUnschedule(): void;
		static IdUsesClock(clock: Gst.Clock): boolean;
		static IdWait(jitter ?: number | bigint): Gst.ClockReturn;
		static IdWaitAsync(func: (clock: Gst.Clock, time: number | bigint) => boolean, destroyData: () => void): Gst.ClockReturn;
		addObservation(slave: number | bigint, master: number | bigint, rSquared: number): boolean;
		addObservationUnapplied(slave: number | bigint, master: number | bigint, rSquared: number, internal ?: number | bigint, external ?: number | bigint, rateNum ?: number | bigint, rateDenom ?: number | bigint): boolean;
		adjustUnlocked(internal: number | bigint): number | bigint;
		adjustWithCalibration(internalTarget: number | bigint, cinternal: number | bigint, cexternal: number | bigint, cnum: number | bigint, cdenom: number | bigint): number | bigint;
		getCalibration(internal ?: number | bigint, external ?: number | bigint, rateNum ?: number | bigint, rateDenom ?: number | bigint): void;
		getInternalTime(): number | bigint;
		getMaster(): Gst.Clock;
		getResolution(): number | bigint;
		getTime(): number | bigint;
		getTimeout(): number | bigint;
		isSynced(): boolean;
		newPeriodicId(startTime: number | bigint, interval: number | bigint): void;
		newSingleShotId(time: number | bigint): void;
		periodicIdReinit(startTime: number | bigint, interval: number | bigint): boolean;
		setCalibration(internal: number | bigint, external: number | bigint, rateNum: number | bigint, rateDenom: number | bigint): void;
		setMaster(master: Gst.Clock | undefined | null): boolean;
		setResolution(resolution: number | bigint): number | bigint;
		setSynced(synced: boolean): void;
		setTimeout(timeout: number | bigint): void;
		singleShotIdReinit(time: number | bigint): boolean;
		unadjustUnlocked(external: number | bigint): number | bigint;
		unadjustWithCalibration(externalTarget: number | bigint, cinternal: number | bigint, cexternal: number | bigint, cnum: number | bigint, cdenom: number | bigint): number | bigint;
		waitForSync(timeout: number | bigint): boolean;
		//TypeScript is complete garbage: 
	}

	class ClockCtor {
		name ?: string;
		parent ?: Gst.Object;
		windowSize ?: number;
		windowThreshold ?: number;
		timeout ?: number;
	}

	class ClockEventListener extends AuGlibEx.IEventListener {
		synced(synced: boolean): void;
	}

	class ControlBinding extends Gst.Object {
		constructor(initializerList ?: ControlBindingCtor);

		parent : Gst.Object;
		name : string;
		pspec : GObject.ParamSpec;
		object : Gst.Object;
		disabled : boolean;


		isDisabled(): boolean;
		setDisabled(disabled: boolean): void;
		//TypeScript is complete garbage: 
	}

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

	class ControlSource extends Gst.Object {
		constructor(initializerList ?: ControlSourceCtor);

		parent : Gst.Object;
		getValueArray : (self: Gst.ControlSource, timestamp: number | bigint, interval: number | bigint, nValues: number, values: number) => boolean;

		controlSourceGetValue(timestamp: number | bigint, value: number): boolean;
		controlSourceGetValueArray(timestamp: number | bigint, interval: number | bigint, nValues: number, values: number[]): boolean;
		//TypeScript is complete garbage: 
	}

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

	class Device extends Gst.Object {
		constructor(initializerList ?: DeviceCtor);

		parent : Gst.Object;
		priv : Gst.DevicePrivate;

		caps : Gst.Caps;
		deviceClass : string;
		displayName : string;
		properties : Gst.Structure;

		createElement(name: string | undefined | null): Gst.Element;
		getCaps(): Gst.Caps;
		getDeviceClass(): string;
		getDisplayName(): string;
		getProperties(): Gst.Structure;
		hasClasses(classes: string): boolean;
		hasClassesv(classes: string[]): boolean;
		reconfigureElement(element: Gst.Element): boolean;
		//TypeScript is complete garbage: 
	}

	class DeviceCtor {
		name ?: string;
		parent ?: Gst.Object;
		displayName ?: string;
		deviceClass ?: string;
	}

	class DeviceEventListener extends AuGlibEx.IEventListener {
		removed(): void;
	}

	class DeviceMonitor extends Gst.Object {
		constructor(initializerList ?: DeviceMonitorCtor);

		parent : Gst.Object;
		priv : Gst.DeviceMonitorPrivate;

		showAll : boolean;

		static New(): Gst.DeviceMonitor;
		addFilter(classes: string | undefined | null, caps: Gst.Caps | undefined | null): number;
		getBus(): Gst.Bus;
		getDevices(): Gst.Device[];
		getProviders(): string[];
		getShowAllDevices(): boolean;
		removeFilter(filterId: number): boolean;
		setShowAllDevices(showAll: boolean): void;
		start(): boolean;
		stop(): void;
		//TypeScript is complete garbage: 
	}

	class DeviceMonitorCtor {
		name ?: string;
		parent ?: Gst.Object;
		showAll ?: boolean;
	}

	class DeviceProvider extends Gst.Object {
		constructor(initializerList ?: DeviceProviderCtor);

		parent : Gst.Object;
		priv : Gst.DeviceProviderPrivate;

		static Register(plugin: Gst.Plugin | undefined | null, name: string, rank: number, type: number): boolean;
		canMonitor(): boolean;
		deviceAdd(device: Gst.Device): void;
		deviceChanged(device: Gst.Device, changedDevice: Gst.Device): void;
		deviceRemove(device: Gst.Device): void;
		getBus(): Gst.Bus;
		getDevices(): Gst.Device[];
		getFactory(): Gst.DeviceProviderFactory;
		getHiddenProviders(): string[];
		getMetadata(key: string): string;
		hideProvider(name: string): void;
		isStarted(): boolean;
		start(): boolean;
		stop(): void;
		unhideProvider(name: string): void;
		//TypeScript is complete garbage: 
	}

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

	class DeviceProviderEventListener extends AuGlibEx.IEventListener {
		providerHidden(object: string): void;
		providerUnhidden(object: string): void;
	}

	class DeviceProviderFactory extends Gst.PluginFeature {
		constructor(initializerList ?: DeviceProviderFactoryCtor);

		static Find(name: string): Gst.DeviceProviderFactory;
		static GetByName(factoryname: string): Gst.DeviceProvider;
		static ListGetDeviceProviders(minrank: Gst.Rank): Gst.DeviceProviderFactory[];
		get(): Gst.DeviceProvider;
		getDeviceProviderType(): number;
		getMetadata(key: string): string;
		getMetadataKeys(): string[];
		hasClasses(classes: string | undefined | null): boolean;
		hasClassesv(classes: string[] | undefined | null): boolean;
		//TypeScript is complete garbage: 
	}

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

	class DoubleRange {
		constructor(initializerList ?: DoubleRangeCtor);

		//TypeScript is complete garbage: 
	}

	class DoubleRangeCtor {
	}

	class DynamicTypeFactory extends Gst.PluginFeature {
		constructor(initializerList ?: DynamicTypeFactoryCtor);

		static Load(factoryname: string): number;
		//TypeScript is complete garbage: 
	}

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

	class Element extends Gst.Object {
		constructor(initializerList ?: ElementCtor);

		object : Gst.Object;
		stateLock : AuGlibEx.RecMutex;
		stateCond : AuGlibEx.Cond;
		stateCookie : number;
		targetState : Gst.State;
		currentState : Gst.State;
		nextState : Gst.State;
		pendingState : Gst.State;
		lastReturn : Gst.StateChangeReturn;
		bus : Gst.Bus;
		clock : Gst.Clock;
		baseTime : number | bigint;
		startTime : number | bigint;
		numpads : number;
		pads : Gst.Pad[];
		numsrcpads : number;
		srcpads : Gst.Pad[];
		numsinkpads : number;
		sinkpads : Gst.Pad[];
		padsCookie : number;
		contexts : Gst.Context[];

		static MakeFromUri(type: Gst.URIType, uri: string, elementname: string | undefined | null): Gst.Element;
		static Register(plugin: Gst.Plugin | undefined | null, name: string, rank: number, type: number): boolean;
		static StateChangeReturnGetName(stateRet: Gst.StateChangeReturn): string;
		static StateGetName(state: Gst.State): string;
		static TypeSetSkipDocumentation(type: number): void;
		abortState(): void;
		addPad(pad: Gst.Pad): boolean;
		addPropertyDeepNotifyWatch(propertyName: string | undefined | null, includeValue: boolean): number;
		addPropertyNotifyWatch(propertyName: string | undefined | null, includeValue: boolean): number;
		callAsync(func: (element: Gst.Element) => void, destroyNotify: () => void): void;
		changeState(transition: Gst.StateChange): Gst.StateChangeReturn;
		continueState(ret: Gst.StateChangeReturn): Gst.StateChangeReturn;
		createAllPads(): void;
		foreachPad(func: (element: Gst.Element, pad: Gst.Pad) => boolean): boolean;
		foreachSinkPad(func: (element: Gst.Element, pad: Gst.Pad) => boolean): boolean;
		foreachSrcPad(func: (element: Gst.Element, pad: Gst.Pad) => boolean): boolean;
		getBaseTime(): number | bigint;
		getBus(): Gst.Bus;
		getClock(): Gst.Clock;
		getCompatiblePad(pad: Gst.Pad, caps: Gst.Caps | undefined | null): Gst.Pad;
		getCompatiblePadTemplate(compattempl: Gst.PadTemplate): Gst.PadTemplate;
		getContext(contextType: string): Gst.Context;
		getContextUnlocked(contextType: string): Gst.Context;
		getContexts(): Gst.Context[];
		getCurrentClockTime(): number | bigint;
		getCurrentRunningTime(): number | bigint;
		getFactory(): Gst.ElementFactory;
		getMetadata(key: string): string;
		getPadTemplate(name: string): Gst.PadTemplate;
		getPadTemplateList(): Gst.PadTemplate[];
		getRequestPad(name: string): Gst.Pad;
		getStartTime(): number | bigint;
		getState(state ?: Gst.State, pending ?: Gst.State, timeout ?: number | bigint): Gst.StateChangeReturn;
		getStaticPad(name: string): Gst.Pad;
		isLockedState(): boolean;
		iteratePads(): Gst.Iterator;
		iterateSinkPads(): Gst.Iterator;
		iterateSrcPads(): Gst.Iterator;
		link(dest: Gst.Element): boolean;
		linkFiltered(dest: Gst.Element, filter: Gst.Caps | undefined | null): boolean;
		linkPads(srcpadname: string | undefined | null, dest: Gst.Element, destpadname: string | undefined | null): boolean;
		linkPadsFiltered(srcpadname: string | undefined | null, dest: Gst.Element, destpadname: string | undefined | null, filter: Gst.Caps | undefined | null): boolean;
		linkPadsFull(srcpadname: string | undefined | null, dest: Gst.Element, destpadname: string | undefined | null, flags: Gst.PadLinkCheck): boolean;
		lostState(): void;
		messageFull(type: Gst.MessageType, domain: number, code: number, text: string | undefined | null, debug: string | undefined | null, file: string, _func: string, line: number): void;
		messageFullWithDetails(type: Gst.MessageType, domain: number, code: number, text: string | undefined | null, debug: string | undefined | null, file: string, _func: string, line: number, structure: Gst.Structure): void;
		noMorePads(): void;
		postMessage(message: Gst.Message): boolean;
		provideClock(): Gst.Clock;
		query(query: Gst.Query): boolean;
		queryConvert(srcFormat: Gst.Format, srcVal: number | bigint, destFormat: Gst.Format, destVal: number | bigint): boolean;
		queryDuration(format: Gst.Format, duration ?: number | bigint): boolean;
		queryPosition(format: Gst.Format, cur ?: number | bigint): boolean;
		releaseRequestPad(pad: Gst.Pad): void;
		removePad(pad: Gst.Pad): boolean;
		removePropertyNotifyWatch(watchId: number): void;
		requestPad(templ: Gst.PadTemplate, name: string | undefined | null, caps: Gst.Caps | undefined | null): Gst.Pad;
		requestPadSimple(name: string): Gst.Pad;
		seek(rate: number, format: Gst.Format, flags: Gst.SeekFlags, startType: Gst.SeekType, start: number | bigint, stopType: Gst.SeekType, stop: number | bigint): boolean;
		seekSimple(format: Gst.Format, seekFlags: Gst.SeekFlags, seekPos: number | bigint): boolean;
		sendEvent(event: Gst.Event): boolean;
		setBaseTime(time: number | bigint): void;
		setBus(bus: Gst.Bus | undefined | null): void;
		setClock(clock: Gst.Clock | undefined | null): boolean;
		setContext(context: Gst.Context): void;
		setLockedState(lockedState: boolean): boolean;
		setStartTime(time: number | bigint): void;
		setState(state: Gst.State): Gst.StateChangeReturn;
		syncStateWithParent(): boolean;
		unlink(dest: Gst.Element): void;
		unlinkPads(srcpadname: string, dest: Gst.Element, destpadname: string): void;
		//TypeScript is complete garbage: 
	}

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

	class ElementEventListener extends AuGlibEx.IEventListener {
		noMorePads(): void;
		padAdded(newPad: Gst.Pad): void;
		padRemoved(oldPad: Gst.Pad): void;
	}

	class ElementFactory extends Gst.PluginFeature {
		constructor(initializerList ?: ElementFactoryCtor);

		static Find(name: string): Gst.ElementFactory;
		static ListFilter(list: Gst.ElementFactory[], caps: Gst.Caps, direction: Gst.PadDirection, subsetonly: boolean): Gst.ElementFactory[];
		static ListGetElements(type: number | bigint, minrank: Gst.Rank): Gst.ElementFactory[];
		static Make(factoryname: string, name: string | undefined | null): Gst.Element;
		static MakeWithProperties(factoryname: string, n: number, names: string[] | undefined | null, values: GObject.Value[] | undefined | null): Gst.Element;
		canSinkAllCaps(caps: Gst.Caps): boolean;
		canSinkAnyCaps(caps: Gst.Caps): boolean;
		canSrcAllCaps(caps: Gst.Caps): boolean;
		canSrcAnyCaps(caps: Gst.Caps): boolean;
		create(name: string | undefined | null): Gst.Element;
		createWithProperties(n: number, names: string[] | undefined | null, values: GObject.Value[] | undefined | null): Gst.Element;
		getElementType(): number;
		getMetadata(key: string): string;
		getMetadataKeys(): string[];
		getNumPadTemplates(): number;
		getSkipDocumentation(): boolean;
		getStaticPadTemplates(): Gst.StaticPadTemplate[];
		getUriProtocols(): string[];
		getUriType(): Gst.URIType;
		hasInterface(interfacename: string): boolean;
		listIsType(type: number | bigint): boolean;
		//TypeScript is complete garbage: 
	}

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

	class FlagSet {
		constructor(initializerList ?: FlagSetCtor);

		static Register(flagsType: number): number;
		//TypeScript is complete garbage: 
	}

	class FlagSetCtor {
	}

	class Fraction {
		constructor(initializerList ?: FractionCtor);

		//TypeScript is complete garbage: 
	}

	class FractionCtor {
	}

	class FractionRange {
		constructor(initializerList ?: FractionRangeCtor);

		//TypeScript is complete garbage: 
	}

	class FractionRangeCtor {
	}

	class GhostPad extends Gst.ProxyPad {
		constructor(initializerList ?: GhostPadCtor);

		pad : Gst.ProxyPad;
		priv : Gst.GhostPadPrivate;

		static NewNoTarget(name: string | undefined | null, dir: Gst.PadDirection): Gst.Pad;
		static NewNoTargetFromTemplate(name: string | undefined | null, templ: Gst.PadTemplate): Gst.Pad;
		static ActivateModeDefault(pad: Gst.Pad, parent: Gst.Object | undefined | null, mode: Gst.PadMode, active: boolean): boolean;
		static InternalActivateModeDefault(pad: Gst.Pad, parent: Gst.Object | undefined | null, mode: Gst.PadMode, active: boolean): boolean;
		construct(): boolean;
		getTarget(): Gst.Pad;
		setTarget(newtarget: Gst.Pad | undefined | null): boolean;
		//TypeScript is complete garbage: 
	}

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

	class Int64Range {
		constructor(initializerList ?: Int64RangeCtor);

		//TypeScript is complete garbage: 
	}

	class Int64RangeCtor {
	}

	class IntRange {
		constructor(initializerList ?: IntRangeCtor);

		//TypeScript is complete garbage: 
	}

	class IntRangeCtor {
	}

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

		object : GObject.InitiallyUnowned;
		name : string;
		parent : Gst.Object;
		flags : number;
		controlRate : number | bigint;
		lastSync : number | bigint;
		gstReserved : void;


		static CheckUniqueness(list: Gst.Object[], name: string): boolean;
		static DefaultDeepNotify(object: GObject.Object, orig: Gst.Object, pspec: GObject.ParamSpec, excludedProps: string[] | undefined | null): void;
		static Replace(oldobj ?: Gst.Object | undefined | null, newobj ?: Gst.Object | undefined | null): boolean;
		addControlBinding(binding: Gst.ControlBinding): boolean;
		defaultError(error: AuGlibEx.Error, debug: string | undefined | null): void;
		getControlBinding(propertyName: string): Gst.ControlBinding;
		getControlRate(): number | bigint;
		getGValueArray(propertyName: string, timestamp: number | bigint, interval: number | bigint, nValues: number, values: GObject.Value[]): boolean;
		getName(): string;
		getParent(): Gst.Object;
		getPathString(): string;
		getValue(propertyName: string, timestamp: number | bigint): GObject.Value;
		hasActiveControlBindings(): boolean;
		hasAncestor(ancestor: Gst.Object): boolean;
		hasAsAncestor(ancestor: Gst.Object): boolean;
		hasAsParent(parent: Gst.Object): boolean;
		removeControlBinding(binding: Gst.ControlBinding): boolean;
		setControlBindingDisabled(propertyName: string, disabled: boolean): void;
		setControlBindingsDisabled(disabled: boolean): void;
		setControlRate(controlRate: number | bigint): void;
		setName(name: string | undefined | null): boolean;
		setParent(parent: Gst.Object): boolean;
		suggestNextSync(): number | bigint;
		syncValues(timestamp: number | bigint): boolean;
		unparent(): void;
		//TypeScript is complete garbage: 
	}

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

	class ObjectEventListener extends AuGlibEx.IEventListener {
		deepNotify(propObject: Gst.Object, prop: GObject.ParamSpec): void;
	}

	class Pad extends Gst.Object {
		constructor(initializerList ?: PadCtor);

		object : Gst.Object;
		elementPrivate : void;
		padtemplate : Gst.PadTemplate;
		direction : Gst.PadDirection;
		streamRecLock : AuGlibEx.RecMutex;
		task : Gst.Task;
		blockCond : AuGlibEx.Cond;
		probes : AuGlibEx.HookList;
		mode : Gst.PadMode;
		activatefunc : (pad: Gst.Pad, parent: Gst.Object) => boolean;
		activatedata : void;
		activatenotify : () => void;
		activatemodefunc : (pad: Gst.Pad, parent: Gst.Object, mode: Gst.PadMode, active: boolean) => boolean;
		activatemodedata : void;
		activatemodenotify : () => void;
		peer : Gst.Pad;
		linkfunc : (pad: Gst.Pad, parent: Gst.Object | undefined | null, peer: Gst.Pad) => Gst.PadLinkReturn;
		linkdata : void;
		linknotify : () => void;
		unlinkfunc : (pad: Gst.Pad, parent: Gst.Object | undefined | null) => void;
		unlinkdata : void;
		unlinknotify : () => void;
		chainfunc : (pad: Gst.Pad, parent: Gst.Object | undefined | null, buffer: Gst.Buffer) => Gst.FlowReturn;
		chaindata : void;
		chainnotify : () => void;
		chainlistfunc : (pad: Gst.Pad, parent: Gst.Object | undefined | null, list: Gst.BufferList) => Gst.FlowReturn;
		chainlistdata : void;
		chainlistnotify : () => void;
		getrangefunc : (pad: Gst.Pad, parent: Gst.Object | undefined | null, offset: number | bigint, length: number, buffer: Gst.Buffer) => Gst.FlowReturn;
		getrangedata : void;
		getrangenotify : () => void;
		eventfunc : (pad: Gst.Pad, parent: Gst.Object | undefined | null, event: Gst.Event) => boolean;
		eventdata : void;
		eventnotify : () => void;
		offset : number | bigint;
		queryfunc : (pad: Gst.Pad, parent: Gst.Object | undefined | null, query: Gst.Query) => boolean;
		querydata : void;
		querynotify : () => void;
		iterintlinkfunc : (pad: Gst.Pad, parent: Gst.Object | undefined | null) => Gst.Iterator;
		iterintlinkdata : void;
		iterintlinknotify : () => void;
		numProbes : number;
		numBlocked : number;
		priv : Gst.PadPrivate;

		caps : Gst.Caps;
		template : Gst.PadTemplate;

		static New(name: string | undefined | null, direction: Gst.PadDirection): Gst.Pad;
		static NewFromStaticTemplate(templ: Gst.StaticPadTemplate, name: string): Gst.Pad;
		static NewFromTemplate(templ: Gst.PadTemplate, name: string | undefined | null): Gst.Pad;
		static LinkGetName(ret: Gst.PadLinkReturn): string;
		activateMode(mode: Gst.PadMode, active: boolean): boolean;
		addProbe(mask: Gst.PadProbeType, callback: (pad: Gst.Pad, info: Gst.PadProbeInfo) => Gst.PadProbeReturn, destroyData: () => void): number;
		canLink(sinkpad: Gst.Pad): boolean;
		chain(buffer: Gst.Buffer): Gst.FlowReturn;
		chainList(list: Gst.BufferList): Gst.FlowReturn;
		checkReconfigure(): boolean;
		createStreamId(parent: Gst.Element, streamId: string | undefined | null): string;
		eventDefault(parent: Gst.Object | undefined | null, event: Gst.Event): boolean;
		forward(forward: (pad: Gst.Pad) => boolean): boolean;
		getAllowedCaps(): Gst.Caps;
		getCurrentCaps(): Gst.Caps;
		getDirection(): Gst.PadDirection;
		getElementPrivate(): void;
		getLastFlowReturn(): Gst.FlowReturn;
		getOffset(): number | bigint;
		getPadTemplate(): Gst.PadTemplate;
		getPadTemplateCaps(): Gst.Caps;
		getParentElement(): Gst.Element;
		getPeer(): Gst.Pad;
		getRange(offset: number | bigint, size: number, buffer: Gst.Buffer): Gst.FlowReturn;
		getSingleInternalLink(): Gst.Pad;
		getStickyEvent(eventType: Gst.EventType, idx: number): Gst.Event;
		getStream(): Gst.Stream;
		getStreamId(): string;
		getTaskState(): Gst.TaskState;
		hasCurrentCaps(): boolean;
		isActive(): boolean;
		isBlocked(): boolean;
		isBlocking(): boolean;
		isLinked(): boolean;
		iterateInternalLinks(): Gst.Iterator;
		iterateInternalLinksDefault(parent: Gst.Object | undefined | null): Gst.Iterator;
		link(sinkpad: Gst.Pad): Gst.PadLinkReturn;
		linkFull(sinkpad: Gst.Pad, flags: Gst.PadLinkCheck): Gst.PadLinkReturn;
		linkMaybeGhosting(sink: Gst.Pad): boolean;
		linkMaybeGhostingFull(sink: Gst.Pad, flags: Gst.PadLinkCheck): boolean;
		markReconfigure(): void;
		needsReconfigure(): boolean;
		pauseTask(): boolean;
		peerQuery(query: Gst.Query): boolean;
		peerQueryAcceptCaps(caps: Gst.Caps): boolean;
		peerQueryCaps(filter: Gst.Caps | undefined | null): Gst.Caps;
		peerQueryConvert(srcFormat: Gst.Format, srcVal: number | bigint, destFormat: Gst.Format, destVal: number | bigint): boolean;
		peerQueryDuration(format: Gst.Format, duration ?: number | bigint): boolean;
		peerQueryPosition(format: Gst.Format, cur ?: number | bigint): boolean;
		proxyQueryAcceptCaps(query: Gst.Query): boolean;
		proxyQueryCaps(query: Gst.Query): boolean;
		pullRange(offset: number | bigint, size: number, buffer: Gst.Buffer): Gst.FlowReturn;
		push(buffer: Gst.Buffer): Gst.FlowReturn;
		pushEvent(event: Gst.Event): boolean;
		pushList(list: Gst.BufferList): Gst.FlowReturn;
		query(query: Gst.Query): boolean;
		queryAcceptCaps(caps: Gst.Caps): boolean;
		queryCaps(filter: Gst.Caps | undefined | null): Gst.Caps;
		queryConvert(srcFormat: Gst.Format, srcVal: number | bigint, destFormat: Gst.Format, destVal: number | bigint): boolean;
		queryDefault(parent: Gst.Object | undefined | null, query: Gst.Query): boolean;
		queryDuration(format: Gst.Format, duration ?: number | bigint): boolean;
		queryPosition(format: Gst.Format, cur ?: number | bigint): boolean;
		removeProbe(id: number): void;
		sendEvent(event: Gst.Event): boolean;
		setActivateFunctionFull(activate: (pad: Gst.Pad, parent: Gst.Object) => boolean, notify: () => void): void;
		setActivatemodeFunctionFull(activatemode: (pad: Gst.Pad, parent: Gst.Object, mode: Gst.PadMode, active: boolean) => boolean, notify: () => void): void;
		setActive(active: boolean): boolean;
		setChainFunctionFull(chain: (pad: Gst.Pad, parent: Gst.Object | undefined | null, buffer: Gst.Buffer) => Gst.FlowReturn, notify: () => void): void;
		setChainListFunctionFull(chainlist: (pad: Gst.Pad, parent: Gst.Object | undefined | null, list: Gst.BufferList) => Gst.FlowReturn, notify: () => void): void;
		setElementPrivate(): void;
		setEventFullFunctionFull(event: (pad: Gst.Pad, parent: Gst.Object | undefined | null, event: Gst.Event) => Gst.FlowReturn, notify: () => void): void;
		setEventFunctionFull(event: (pad: Gst.Pad, parent: Gst.Object | undefined | null, event: Gst.Event) => boolean, notify: () => void): void;
		setGetrangeFunctionFull(get: (pad: Gst.Pad, parent: Gst.Object | undefined | null, offset: number | bigint, length: number, buffer: Gst.Buffer) => Gst.FlowReturn, notify: () => void): void;
		setIterateInternalLinksFunctionFull(iterintlink: (pad: Gst.Pad, parent: Gst.Object | undefined | null) => Gst.Iterator, notify: () => void): void;
		setLinkFunctionFull(link: (pad: Gst.Pad, parent: Gst.Object | undefined | null, peer: Gst.Pad) => Gst.PadLinkReturn, notify: () => void): void;
		setOffset(offset: number | bigint): void;
		setQueryFunctionFull(query: (pad: Gst.Pad, parent: Gst.Object | undefined | null, query: Gst.Query) => boolean, notify: () => void): void;
		setUnlinkFunctionFull(unlink: (pad: Gst.Pad, parent: Gst.Object | undefined | null) => void, notify: () => void): void;
		startTask(func: () => void, notify: () => void): boolean;
		stickyEventsForeach(foreachFunc: (pad: Gst.Pad, event: Gst.Event | undefined | null) => boolean): void;
		stopTask(): boolean;
		storeStickyEvent(event: Gst.Event): Gst.FlowReturn;
		unlink(sinkpad: Gst.Pad): boolean;
		useFixedCaps(): void;
		//TypeScript is complete garbage: 
	}

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

	class PadEventListener extends AuGlibEx.IEventListener {
		linked(peer: Gst.Pad): void;
		unlinked(peer: Gst.Pad): void;
	}

	class PadTemplate extends Gst.Object {
		constructor(initializerList ?: PadTemplateCtor);

		object : Gst.Object;
		nameTemplate : string;
		direction : Gst.PadDirection;
		presence : Gst.PadPresence;
		caps : Gst.Caps;

		gtype : number;

		static New(nameTemplate: string, direction: Gst.PadDirection, presence: Gst.PadPresence, caps: Gst.Caps): Gst.PadTemplate;
		static NewFromStaticPadTemplateWithGtype(padTemplate: Gst.StaticPadTemplate, padType: number): Gst.PadTemplate;
		static NewWithGtype(nameTemplate: string, direction: Gst.PadDirection, presence: Gst.PadPresence, caps: Gst.Caps, padType: number): Gst.PadTemplate;
		getCaps(): Gst.Caps;
		getDocumentationCaps(): Gst.Caps;
		padCreated(pad: Gst.Pad): void;
		setDocumentationCaps(caps: Gst.Caps): void;
		//TypeScript is complete garbage: 
	}

	class PadTemplateCtor {
		name ?: string;
		parent ?: Gst.Object;
		nameTemplate ?: string;
		direction ?: Gst.PadDirection;
		presence ?: Gst.PadPresence;
		gtype ?: any;
	}

	class PadTemplateEventListener extends AuGlibEx.IEventListener {
		padCreated(pad: Gst.Pad): void;
	}

	class ParamArray extends GObject.ParamSpec {
		constructor(initializerList ?: ParamArrayCtor);

		//TypeScript is complete garbage: 
	}

	class ParamArrayCtor {
	}

	class ParamFraction extends GObject.ParamSpec {
		constructor(initializerList ?: ParamFractionCtor);

		//TypeScript is complete garbage: 
	}

	class ParamFractionCtor {
	}

	class Pipeline extends Gst.Bin implements Gst.ChildProxy {
		constructor(initializerList ?: PipelineCtor);

		bin : Gst.Bin;
		fixedClock : Gst.Clock;
		streamTime : number | bigint;
		delay : number | bigint;
		priv : Gst.PipelinePrivate;

		autoFlushBus : boolean;
		latency : number | bigint;

		autoClock(): void;
		getAutoFlushBus(): boolean;
		getDelay(): number | bigint;
		getLatency(): number | bigint;
		getPipelineClock(): Gst.Clock;
		setAutoFlushBus(autoFlush: boolean): void;
		setDelay(delay: number | bigint): void;
		setLatency(latency: number | bigint): void;
		useClock(clock: Gst.Clock | undefined | null): void;
		//TypeScript is complete garbage: 
	}

	class PipelineCtor {
		name ?: string;
		parent ?: Gst.Object;
		asyncHandling ?: boolean;
		messageForward ?: boolean;
		delay ?: number;
		autoFlushBus ?: boolean;
		latency ?: number;
	}

	class Plugin extends Gst.Object {
		constructor(initializerList ?: PluginCtor);

		static ListFree(list: Gst.Plugin[]): void;
		static LoadByName(name: string): Gst.Plugin;
		static LoadFile(filename: string): Gst.Plugin;
		static RegisterStatic(majorVersion: number, minorVersion: number, name: string, description: string, initFunc: (plugin: Gst.Plugin) => boolean, version: string, license: string, source: string, package: string, origin: string): boolean;
		static RegisterStaticFull(majorVersion: number, minorVersion: number, name: string, description: string, initFullFunc: (plugin: Gst.Plugin) => boolean, version: string, license: string, source: string, package: string, origin: string): boolean;
		addDependency(envVars: string[] | undefined | null, paths: string[] | undefined | null, names: string[] | undefined | null, flags: Gst.PluginDependencyFlags): void;
		addDependencySimple(envVars: string | undefined | null, paths: string | undefined | null, names: string | undefined | null, flags: Gst.PluginDependencyFlags): void;
		getCacheData(): Gst.Structure;
		getDescription(): string;
		getFilename(): string;
		getLicense(): string;
		getOrigin(): string;
		getPackage(): string;
		getReleaseDateString(): string;
		getSource(): string;
		getVersion(): string;
		isLoaded(): boolean;
		load(): Gst.Plugin;
		setCacheData(cacheData: Gst.Structure): void;
		//TypeScript is complete garbage: 
	}

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

	class PluginFeature extends Gst.Object {
		constructor(initializerList ?: PluginFeatureCtor);

		static ListCopy(list: Gst.PluginFeature[]): Gst.PluginFeature[];
		static ListDebug(list: Gst.PluginFeature[]): void;
		static ListFree(list: Gst.PluginFeature[]): void;
		static RankCompareFunc(): number;
		checkVersion(minMajor: number, minMinor: number, minMicro: number): boolean;
		getPlugin(): Gst.Plugin;
		getPluginName(): string;
		getRank(): number;
		load(): Gst.PluginFeature;
		setRank(rank: number): void;
		//TypeScript is complete garbage: 
	}

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

	class ProxyPad extends Gst.Pad {
		constructor(initializerList ?: ProxyPadCtor);

		pad : Gst.Pad;
		priv : Gst.ProxyPadPrivate;

		static ChainDefault(pad: Gst.Pad, parent: Gst.Object | undefined | null, buffer: Gst.Buffer): Gst.FlowReturn;
		static ChainListDefault(pad: Gst.Pad, parent: Gst.Object | undefined | null, list: Gst.BufferList): Gst.FlowReturn;
		static GetrangeDefault(pad: Gst.Pad, parent: Gst.Object, offset: number | bigint, size: number, buffer: Gst.Buffer): Gst.FlowReturn;
		static IterateInternalLinksDefault(pad: Gst.Pad, parent: Gst.Object | undefined | null): Gst.Iterator;
		getInternal(): Gst.ProxyPad;
		//TypeScript is complete garbage: 
	}

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

	class Registry extends Gst.Object {
		constructor(initializerList ?: RegistryCtor);

		object : Gst.Object;
		priv : Gst.RegistryPrivate;

		static ForkIsEnabled(): boolean;
		static ForkSetEnabled(enabled: boolean): void;
		static Get(): Gst.Registry;
		addFeature(feature: Gst.PluginFeature): boolean;
		addPlugin(plugin: Gst.Plugin): boolean;
		checkFeatureVersion(featureName: string, minMajor: number, minMinor: number, minMicro: number): boolean;
		featureFilter(filter: (feature: Gst.PluginFeature) => boolean, first: boolean): Gst.PluginFeature[];
		findFeature(name: string, type: number): Gst.PluginFeature;
		findPlugin(name: string): Gst.Plugin;
		getFeatureList(type: number): Gst.PluginFeature[];
		getFeatureListByPlugin(name: string): Gst.PluginFeature[];
		getFeatureListCookie(): number;
		getPluginList(): Gst.Plugin[];
		lookup(filename: string): Gst.Plugin;
		lookupFeature(name: string): Gst.PluginFeature;
		pluginFilter(filter: (plugin: Gst.Plugin) => boolean, first: boolean): Gst.Plugin[];
		removeFeature(feature: Gst.PluginFeature): void;
		removePlugin(plugin: Gst.Plugin): void;
		scanPath(path: string): boolean;
		//TypeScript is complete garbage: 
	}

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

	class RegistryEventListener extends AuGlibEx.IEventListener {
		featureAdded(feature: Gst.PluginFeature): void;
		pluginAdded(plugin: Gst.Plugin): void;
	}

	class SharedTaskPool extends Gst.TaskPool {
		constructor(initializerList ?: SharedTaskPoolCtor);

		parent : Gst.TaskPool;
		priv : Gst.SharedTaskPoolPrivate;

		getMaxThreads(): number;
		setMaxThreads(maxThreads: number): void;
		//TypeScript is complete garbage: 
	}

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

	class Stream extends Gst.Object {
		constructor(initializerList ?: StreamCtor);

		object : Gst.Object;
		streamId : string;
		priv : Gst.StreamPrivate;

		caps : Gst.Caps;
		streamFlags : Gst.StreamFlags;
		streamType : Gst.StreamType;
		tags : Gst.TagList;

		static New(streamId: string | undefined | null, caps: Gst.Caps | undefined | null, type: Gst.StreamType, flags: Gst.StreamFlags): Gst.Stream;
		getCaps(): Gst.Caps;
		getStreamFlags(): Gst.StreamFlags;
		getStreamId(): string;
		getStreamType(): Gst.StreamType;
		getTags(): Gst.TagList;
		setCaps(caps: Gst.Caps | undefined | null): void;
		setStreamFlags(flags: Gst.StreamFlags): void;
		setStreamType(streamType: Gst.StreamType): void;
		setTags(tags: Gst.TagList | undefined | null): void;
		//TypeScript is complete garbage: 
	}

	class StreamCtor {
		name ?: string;
		parent ?: Gst.Object;
		streamId ?: string;
		streamFlags ?: Gst.StreamFlags;
		streamType ?: Gst.StreamType;
	}

	class StreamCollection extends Gst.Object {
		constructor(initializerList ?: StreamCollectionCtor);

		object : Gst.Object;
		upstreamId : string;
		priv : Gst.StreamCollectionPrivate;


		static New(upstreamId: string | undefined | null): Gst.StreamCollection;
		addStream(stream: Gst.Stream): boolean;
		getSize(): number;
		getStream(index: number): Gst.Stream;
		getUpstreamId(): string;
		//TypeScript is complete garbage: 
	}

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

	class StreamCollectionEventListener extends AuGlibEx.IEventListener {
		streamNotify(object: Gst.Stream, p0: GObject.ParamSpec): void;
	}

	class SystemClock extends Gst.Clock {
		constructor(initializerList ?: SystemClockCtor);

		clock : Gst.Clock;
		priv : Gst.SystemClockPrivate;

		clockType : Gst.ClockType;

		static Obtain(): Gst.Clock;
		static SetDefault(newClock: Gst.Clock | undefined | null): void;
		//TypeScript is complete garbage: 
	}

	class SystemClockCtor {
		name ?: string;
		parent ?: Gst.Object;
		windowSize ?: number;
		windowThreshold ?: number;
		timeout ?: number;
		clockType ?: Gst.ClockType;
	}

	class Task extends Gst.Object {
		constructor(initializerList ?: TaskCtor);

		object : Gst.Object;
		state : Gst.TaskState;
		cond : AuGlibEx.Cond;
		lock : AuGlibEx.RecMutex;
		func : () => void;
		userData : void;
		notify : () => void;
		running : boolean;
		thread : AuGlibEx.Thread;
		priv : Gst.TaskPrivate;

		static New(func: () => void, notify: () => void): Gst.Task;
		static CleanupAll(): void;
		getPool(): Gst.TaskPool;
		getState(): Gst.TaskState;
		join(): boolean;
		pause(): boolean;
		resume(): boolean;
		setEnterCallback(enterFunc: (task: Gst.Task, thread: AuGlibEx.Thread) => void, notify: () => void): void;
		setLeaveCallback(leaveFunc: (task: Gst.Task, thread: AuGlibEx.Thread) => void, notify: () => void): void;
		setLock(mutex: AuGlibEx.RecMutex): void;
		setPool(pool: Gst.TaskPool): void;
		setState(state: Gst.TaskState): boolean;
		start(): boolean;
		stop(): boolean;
		//TypeScript is complete garbage: 
	}

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

	class TaskPool extends Gst.Object {
		constructor(initializerList ?: TaskPoolCtor);

		object : Gst.Object;
		pool : AuGlibEx.ThreadPool;

		static New(): Gst.TaskPool;
		cleanup(): void;
		disposeHandle(): void;
		join(): void;
		prepare(): void;
		push(func: () => void): void;
		//TypeScript is complete garbage: 
	}

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

	class Tracer extends Gst.Object {
		constructor(initializerList ?: TracerCtor);

		parent : Gst.Object;
		priv : Gst.TracerPrivate;

		params : string;

		static Register(plugin: Gst.Plugin | undefined | null, name: string, type: number): boolean;
		//TypeScript is complete garbage: 
	}

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

	class TracerFactory extends Gst.PluginFeature {
		constructor(initializerList ?: TracerFactoryCtor);

		static GetList(): Gst.TracerFactory[];
		getTracerType(): number;
		//TypeScript is complete garbage: 
	}

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

	class TracerRecord extends Gst.Object {
		constructor(initializerList ?: TracerRecordCtor);

		//TypeScript is complete garbage: 
	}

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

	class TypeFindFactory extends Gst.PluginFeature {
		constructor(initializerList ?: TypeFindFactoryCtor);

		static GetList(): Gst.TypeFindFactory[];
		callFunction(find: Gst.TypeFind): void;
		getCaps(): Gst.Caps;
		getExtensions(): string[];
		hasFunction(): boolean;
		//TypeScript is complete garbage: 
	}

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

	class ValueArray {
		constructor(initializerList ?: ValueArrayCtor);

		static AppendAndTakeValue(value: GObject.Value, appendValue: GObject.Value): void;
		static AppendValue(value: GObject.Value, appendValue: GObject.Value): void;
		static GetSize(value: GObject.Value): number;
		static GetValue(value: GObject.Value, index: number): GObject.Value;
		static Init(value: GObject.Value, prealloc: number): GObject.Value;
		static PrependValue(value: GObject.Value, prependValue: GObject.Value): void;
		//TypeScript is complete garbage: 
	}

	class ValueArrayCtor {
	}

	class ValueList {
		constructor(initializerList ?: ValueListCtor);

		static AppendAndTakeValue(value: GObject.Value, appendValue: GObject.Value): void;
		static AppendValue(value: GObject.Value, appendValue: GObject.Value): void;
		static Concat(dest: GObject.Value, value1: GObject.Value, value2: GObject.Value): void;
		static GetSize(value: GObject.Value): number;
		static GetValue(value: GObject.Value, index: number): GObject.Value;
		static Init(value: GObject.Value, prealloc: number): GObject.Value;
		static Merge(dest: GObject.Value, value1: GObject.Value, value2: GObject.Value): void;
		static PrependValue(value: GObject.Value, prependValue: GObject.Value): void;
		//TypeScript is complete garbage: 
	}

	class ValueListCtor {
	}
}