import * as VScript from "vscript";
import * as _SDP from "./SDP";
import * as _Memory from "./Memory";
import * as _MetadataProcessor from "./MetadataProcessor";
import * as _PTP from "./PTP";
import * as _Audio from "./Audio";
import * as _Video from "./Video";
import * as _NetworkInterfaces from "./NetworkInterfaces";
import * as _Time from "./Time";
import * as _Primitives from "./Primitives";
export declare const lift: {
    readonly AllDerivedPtpTraits: (kwl: string | null, socket: VScript.VSocket) => AllDerivedPtpTraits | null;
    readonly AllSettingsPhaseMismatch: (kwl: string | null, socket: VScript.VSocket) => AllSettingsPhaseMismatch | null;
    readonly AllSettings: (kwl: string | null, socket: VScript.VSocket) => AllSettings | null;
    readonly AllDiagnostics: (kwl: string | null, socket: VScript.VSocket) => AllDiagnostics | null;
    readonly MPacketDebugInfo: (x: any | null, _: VScript.VSocket) => MPacketDebugInfo | null;
    readonly Session: (kwl: string | null, socket: VScript.VSocket) => Session | null;
    readonly SessionLastAcceptedTrack: (x: any | null, _: VScript.VSocket) => SessionLastAcceptedTrack | null;
    readonly SessionVersionWindow: (kwl: string | null, socket: VScript.VSocket) => SessionVersionWindow | null;
    readonly SessionEventCountersNumRejectedSdps: (kwl: string | null, socket: VScript.VSocket) => SessionEventCountersNumRejectedSdps | null;
    readonly SessionEventCounters: (kwl: string | null, socket: VScript.VSocket) => SessionEventCounters | null;
    readonly SessionInterfaces: (kwl: string | null, socket: VScript.VSocket) => SessionInterfaces | null;
    readonly SessionPassthroughReceivers: (kwl: string | null, socket: VScript.VSocket) => SessionPassthroughReceivers | null;
    readonly SessionAncBurstReceivers: (kwl: string | null, socket: VScript.VSocket) => SessionAncBurstReceivers | null;
    readonly SessionAudioReceivers: (kwl: string | null, socket: VScript.VSocket) => SessionAudioReceivers | null;
    readonly SessionVideoReceivers: (kwl: string | null, socket: VScript.VSocket) => SessionVideoReceivers | null;
    readonly SessionSwitchCapability: (kwl: string | null, socket: VScript.VSocket) => SessionSwitchCapability | null;
    readonly VideoReceiver: (kwl: string | null, socket: VScript.VSocket) => VideoReceiver | null;
    readonly VideoReceiverVideoSpecificMetadataDecoderCounters: (x: any | null, _: VScript.VSocket) => VideoReceiverVideoSpecificMetadataDecoderCounters | null;
    readonly VideoReceiverVideoSpecificMetadataDecoder: (kwl: string | null, socket: VScript.VSocket) => VideoReceiverVideoSpecificMetadataDecoder | null;
    readonly VideoReceiverVideoSpecificOutput: (kwl: string | null, socket: VScript.VSocket) => VideoReceiverVideoSpecificOutput | null;
    readonly VideoReceiverVideoSpecificFlowPartitions: (kwl: string | null, socket: VScript.VSocket) => VideoReceiverVideoSpecificFlowPartitions | null;
    readonly VideoReceiverVideoSpecificEventCounters: (kwl: string | null, socket: VScript.VSocket) => VideoReceiverVideoSpecificEventCounters | null;
    readonly VideoReceiverVideoSpecificErrorCounters: (kwl: string | null, socket: VScript.VSocket) => VideoReceiverVideoSpecificErrorCounters | null;
    readonly VideoReceiverVideoSpecificCapabilities: (kwl: string | null, socket: VScript.VSocket) => VideoReceiverVideoSpecificCapabilities | null;
    readonly VideoReceiverVideoSpecific: (kwl: string | null, socket: VScript.VSocket) => VideoReceiverVideoSpecific | null;
    readonly AncBurstReceiver: (kwl: string | null, socket: VScript.VSocket) => AncBurstReceiver | null;
    readonly AncBurstReceiverMediaClock: (kwl: string | null, socket: VScript.VSocket) => AncBurstReceiverMediaClock | null;
    readonly SoftMetadataStatistics: (x: any | null, _: VScript.VSocket) => SoftMetadataStatistics | null;
    readonly VideoServo: (kwl: string | null, socket: VScript.VSocket) => VideoServo | null;
    readonly PassthroughReceiver: (kwl: string | null, socket: VScript.VSocket) => PassthroughReceiver | null;
    readonly PassthroughReceiverFlowPartitions: (kwl: string | null, socket: VScript.VSocket) => PassthroughReceiverFlowPartitions | null;
    readonly PassthroughReceiverIssues: (kwl: string | null, socket: VScript.VSocket) => PassthroughReceiverIssues | null;
    readonly PassthroughReceiverEgress: (kwl: string | null, socket: VScript.VSocket) => PassthroughReceiverEgress | null;
    readonly PassthroughEssence: (kwl: string | null, socket: VScript.VSocket) => PassthroughEssence | null;
    readonly AudioReceiver: (kwl: string | null, socket: VScript.VSocket) => AudioReceiver | null;
    readonly AudioReceiverAudioSpecificOutput: (kwl: string | null, socket: VScript.VSocket) => AudioReceiverAudioSpecificOutput | null;
    readonly AudioReceiverAudioSpecificFlowPartitions: (kwl: string | null, socket: VScript.VSocket) => AudioReceiverAudioSpecificFlowPartitions | null;
    readonly AudioReceiverAudioSpecific: (kwl: string | null, socket: VScript.VSocket) => AudioReceiverAudioSpecific | null;
    readonly AudioServo: (kwl: string | null, socket: VScript.VSocket) => AudioServo | null;
    readonly MediaReceiver: (kwl: string | null, socket: VScript.VSocket) => MediaReceiver | null;
    readonly MediaReceiverLatencySpread: (kwl: string | null, socket: VScript.VSocket) => MediaReceiverLatencySpread | null;
    readonly MediaReceiverRedundancyLevels: (kwl: string | null, socket: VScript.VSocket) => MediaReceiverRedundancyLevels | null;
    readonly MediaReceiverRequiredRedundancyLevel: (kwl: string | null, socket: VScript.VSocket) => MediaReceiverRequiredRedundancyLevel | null;
    readonly MediaReceiverReadDelayPerStream: (kwl: string | null, socket: VScript.VSocket) => MediaReceiverReadDelayPerStream | null;
    readonly MediaReceiverReadDelay: (kwl: string | null, socket: VScript.VSocket) => MediaReceiverReadDelay | null;
    readonly MediaReceiverEventCounters: (kwl: string | null, socket: VScript.VSocket) => MediaReceiverEventCounters | null;
    readonly MediaReceiverErrorCounters: (kwl: string | null, socket: VScript.VSocket) => MediaReceiverErrorCounters | null;
    readonly MediaReceiverFlightPermit: (kwl: string | null, socket: VScript.VSocket) => MediaReceiverFlightPermit | null;
    readonly MediaReceiverIssues: (kwl: string | null, socket: VScript.VSocket) => MediaReceiverIssues | null;
    readonly CurrentRedundancyLevels: (kwl: string | null, socket: VScript.VSocket) => CurrentRedundancyLevels | null;
    readonly ErrorCounter: (x: any | null, _: VScript.VSocket) => ErrorCounter | null;
    readonly Timing: (kwl: string | null, socket: VScript.VSocket) => Timing | null;
    readonly PassthroughFlowPartition: (kwl: string | null, socket: VScript.VSocket) => PassthroughFlowPartition | null;
    readonly AudioFlowPartition: (kwl: string | null, socket: VScript.VSocket) => AudioFlowPartition | null;
    readonly VideoFlowPartition: (kwl: string | null, socket: VScript.VSocket) => VideoFlowPartition | null;
    readonly AffineNetworkSource: (kwl: string | null, socket: VScript.VSocket) => AffineNetworkSource | null;
    readonly NetworkSource: (kwl: string | null, socket: VScript.VSocket) => NetworkSource | null;
    readonly PacketStream: (kwl: string | null, socket: VScript.VSocket) => PacketStream | null;
    readonly MPacket: (x: any | null, _: VScript.VSocket) => MPacket | null;
    readonly PacketStreamIngressTiming: (kwl: string | null, socket: VScript.VSocket) => PacketStreamIngressTiming | null;
    readonly Buffer: (kwl: string | null, socket: VScript.VSocket) => Buffer | null;
    readonly RTPInputStatistics: (kwl: string | null, socket: VScript.VSocket) => RTPInputStatistics | null;
    readonly Expectations: (kwl: string | null, socket: VScript.VSocket) => Expectations | null;
    readonly ExpectationsMpacketFrom: (kwl: string | null, socket: VScript.VSocket) => ExpectationsMpacketFrom | null;
    readonly Egress: (kwl: string | null, socket: VScript.VSocket) => Egress | null;
    readonly EgressTracks: (x: any | null, _: VScript.VSocket) => EgressTracks | null;
    readonly Ingress: (kwl: string | null, socket: VScript.VSocket) => Ingress | null;
    readonly CountableErrorHandler: (kwl: string | null, socket: VScript.VSocket) => CountableErrorHandler | null;
};
export declare const lower: {
    readonly AllDerivedPtpTraits: (ref: AllDerivedPtpTraits | null) => string | null;
    readonly AllSettingsPhaseMismatch: (ref: AllSettingsPhaseMismatch | null) => string | null;
    readonly AllSettings: (ref: AllSettings | null) => string | null;
    readonly AllDiagnostics: (ref: AllDiagnostics | null) => string | null;
    readonly MPacketDebugInfo: (x: MPacketDebugInfo | null) => (number | boolean)[] | null;
    readonly Session: (ref: Session | null) => string | null;
    readonly SessionLastAcceptedTrack: (x: SessionLastAcceptedTrack | null) => (number | "A" | [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number] | "B")[] | null;
    readonly SessionVersionWindow: (ref: SessionVersionWindow | null) => string | null;
    readonly SessionEventCountersNumRejectedSdps: (ref: SessionEventCountersNumRejectedSdps | null) => string | null;
    readonly SessionEventCounters: (ref: SessionEventCounters | null) => string | null;
    readonly SessionInterfaces: (ref: SessionInterfaces | null) => string | null;
    readonly SessionPassthroughReceivers: (ref: SessionPassthroughReceivers | null) => string | null;
    readonly SessionAncBurstReceivers: (ref: SessionAncBurstReceivers | null) => string | null;
    readonly SessionAudioReceivers: (ref: SessionAudioReceivers | null) => string | null;
    readonly SessionVideoReceivers: (ref: SessionVideoReceivers | null) => string | null;
    readonly SessionSwitchCapability: (ref: SessionSwitchCapability | null) => string | null;
    readonly VideoReceiver: (ref: VideoReceiver | null) => string | null;
    readonly VideoReceiverVideoSpecificMetadataDecoderCounters: (x: VideoReceiverVideoSpecificMetadataDecoderCounters | null) => number[] | null;
    readonly VideoReceiverVideoSpecificMetadataDecoder: (ref: VideoReceiverVideoSpecificMetadataDecoder | null) => string | null;
    readonly VideoReceiverVideoSpecificOutput: (ref: VideoReceiverVideoSpecificOutput | null) => string | null;
    readonly VideoReceiverVideoSpecificFlowPartitions: (ref: VideoReceiverVideoSpecificFlowPartitions | null) => string | null;
    readonly VideoReceiverVideoSpecificEventCounters: (ref: VideoReceiverVideoSpecificEventCounters | null) => string | null;
    readonly VideoReceiverVideoSpecificErrorCounters: (ref: VideoReceiverVideoSpecificErrorCounters | null) => string | null;
    readonly VideoReceiverVideoSpecificCapabilities: (ref: VideoReceiverVideoSpecificCapabilities | null) => string | null;
    readonly VideoReceiverVideoSpecific: (ref: VideoReceiverVideoSpecific | null) => string | null;
    readonly AncBurstReceiver: (ref: AncBurstReceiver | null) => string | null;
    readonly AncBurstReceiverMediaClock: (ref: AncBurstReceiverMediaClock | null) => string | null;
    readonly SoftMetadataStatistics: (x: SoftMetadataStatistics | null) => number[] | null;
    readonly VideoServo: (ref: VideoServo | null) => string | null;
    readonly PassthroughReceiver: (ref: PassthroughReceiver | null) => string | null;
    readonly PassthroughReceiverFlowPartitions: (ref: PassthroughReceiverFlowPartitions | null) => string | null;
    readonly PassthroughReceiverIssues: (ref: PassthroughReceiverIssues | null) => string | null;
    readonly PassthroughReceiverEgress: (ref: PassthroughReceiverEgress | null) => string | null;
    readonly PassthroughEssence: (ref: PassthroughEssence | null) => string | null;
    readonly AudioReceiver: (ref: AudioReceiver | null) => string | null;
    readonly AudioReceiverAudioSpecificOutput: (ref: AudioReceiverAudioSpecificOutput | null) => string | null;
    readonly AudioReceiverAudioSpecificFlowPartitions: (ref: AudioReceiverAudioSpecificFlowPartitions | null) => string | null;
    readonly AudioReceiverAudioSpecific: (ref: AudioReceiverAudioSpecific | null) => string | null;
    readonly AudioServo: (ref: AudioServo | null) => string | null;
    readonly MediaReceiver: (ref: MediaReceiver | null) => string | null;
    readonly MediaReceiverLatencySpread: (ref: MediaReceiverLatencySpread | null) => string | null;
    readonly MediaReceiverRedundancyLevels: (ref: MediaReceiverRedundancyLevels | null) => string | null;
    readonly MediaReceiverRequiredRedundancyLevel: (ref: MediaReceiverRequiredRedundancyLevel | null) => string | null;
    readonly MediaReceiverReadDelayPerStream: (ref: MediaReceiverReadDelayPerStream | null) => string | null;
    readonly MediaReceiverReadDelay: (ref: MediaReceiverReadDelay | null) => string | null;
    readonly MediaReceiverEventCounters: (ref: MediaReceiverEventCounters | null) => string | null;
    readonly MediaReceiverErrorCounters: (ref: MediaReceiverErrorCounters | null) => string | null;
    readonly MediaReceiverFlightPermit: (ref: MediaReceiverFlightPermit | null) => string | null;
    readonly MediaReceiverIssues: (ref: MediaReceiverIssues | null) => string | null;
    readonly CurrentRedundancyLevels: (ref: CurrentRedundancyLevels | null) => string | null;
    readonly ErrorCounter: (x: ErrorCounter | null) => number[] | null;
    readonly Timing: (ref: Timing | null) => string | null;
    readonly PassthroughFlowPartition: (ref: PassthroughFlowPartition | null) => string | null;
    readonly AudioFlowPartition: (ref: AudioFlowPartition | null) => string | null;
    readonly VideoFlowPartition: (ref: VideoFlowPartition | null) => string | null;
    readonly AffineNetworkSource: (ref: AffineNetworkSource | null) => string | null;
    readonly NetworkSource: (ref: NetworkSource | null) => string | null;
    readonly PacketStream: (ref: PacketStream | null) => string | null;
    readonly MPacket: (x: MPacket | null) => number[] | null;
    readonly PacketStreamIngressTiming: (ref: PacketStreamIngressTiming | null) => string | null;
    readonly Buffer: (ref: Buffer | null) => string | null;
    readonly RTPInputStatistics: (ref: RTPInputStatistics | null) => string | null;
    readonly Expectations: (ref: Expectations | null) => string | null;
    readonly ExpectationsMpacketFrom: (ref: ExpectationsMpacketFrom | null) => string | null;
    readonly Egress: (ref: Egress | null) => string | null;
    readonly EgressTracks: (x: EgressTracks | null) => Track[] | null;
    readonly Ingress: (ref: Ingress | null) => string | null;
    readonly CountableErrorHandler: (ref: CountableErrorHandler | null) => string | null;
};
export declare type SamplingStructure = "Interlaced" | "Progressive";
export declare type ErrorHandler = "Ignore" | "RestartReceiver";
export declare type MediaReceiverType = "AncBurst" | "Audio" | "Video";
export declare class CountableErrorHandler {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get threshold(): VScript.rwKeyword<number, number, CountableErrorHandler>;
    get above_threshold_do(): VScript.rwKeyword<ErrorHandler, ErrorHandler, CountableErrorHandler>;
}
export declare type TrackControllerState = "DISC" | "A" | "B" | "XA" | "XB" | "AX" | "BX" | "AB" | "BA";
export declare type Track = "A" | "B";
export declare type IngressTrackState = "Inactive" | "Activating" | "Active";
export declare type EgressState = "Inactive" | "Activating" | "Active";
export declare type SwitchType = "DTS_BBM" | "DTS_MBB";
export declare type FrameShiftPolicy = "Prohibit" | "PermitFrameShifts" | "PermitSubframeShifts";
export declare type LogicalSwitchTime = "DoNotSwitch" | "Patch" | "Past" | "WithinCooldownTime" | "WithinPreparationTime" | "Future";
export declare class Ingress {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get sdp_a(): VScript.rKeyword<IngressTrackState, IngressTrackState, Ingress>;
    get sdp_b(): VScript.rKeyword<IngressTrackState, IngressTrackState, Ingress>;
}
interface EgressTracks {
    current: Track;
    incoming: Track;
}
export declare class Egress {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get state(): VScript.rKeyword<IngressTrackState, IngressTrackState, Egress>;
    get soft_metadata(): VScript.rKeyword<Track, Track, Egress>;
    get frozen(): VScript.rKeyword<boolean, boolean, Egress>;
    get tracks(): VScript.rKeyword<any, EgressTracks | null, this>;
    get source(): VScript.rKeyword<string | null, Buffer | null, Egress>;
    get primary_region_holds(): VScript.rKeyword<Track, Track, Egress>;
}
declare class ExpectationsMpacketFrom {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get sdp_a(): VScript.rKeyword<boolean, boolean, ExpectationsMpacketFrom>;
    get sdp_b(): VScript.rKeyword<boolean, boolean, ExpectationsMpacketFrom>;
}
export declare class Expectations {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get sof(): VScript.rKeyword<boolean, boolean, Expectations>;
    get mpacket_from(): ExpectationsMpacketFrom;
}
export declare class RTPInputStatistics {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get input_oom(): VScript.rKeyword<[number, number, number, number], [number, number, number, number], RTPInputStatistics>;
    get queue_full(): VScript.rKeyword<number, number, RTPInputStatistics>;
    get lowest_memfree(): VScript.rKeyword<number, number, RTPInputStatistics>;
    get memfree(): VScript.rKeyword<number, number, RTPInputStatistics>;
    get highest_fifo_usedw(): VScript.rKeyword<number, number, RTPInputStatistics>;
    get fifo_usedw(): VScript.rKeyword<number, number, RTPInputStatistics>;
    /**
      Clear statistic counter
    */
    get clear(): VScript.wKeyword<"Click", "Click", RTPInputStatistics>;
}
export declare class RTPInputStatisticsAsArrayRow<ParentType extends VScript.StronglyTypedSubtree> extends RTPInputStatistics {
    readonly index: number;
    readonly parent: ParentType;
    constructor(st: VScript.Subtree, index: number, parent: ParentType);
}
export declare class Buffer {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get id(): VScript.rKeyword<number, number, Buffer>;
    get num_inlets(): VScript.rKeyword<number, number, Buffer>;
    get num_outlets(): VScript.rKeyword<number, number, Buffer>;
}
export declare class BufferAsTableRow extends Buffer {
    readonly enclosing_table: VScript.StronglyTypedTable<Buffer>;
    readonly index: number;
    constructor(raw_row: VScript.TableRow, enclosing_table: VScript.StronglyTypedTable<Buffer>);
}
export declare class PacketStreamIngressTiming {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get nominal_mpacket_interval(): VScript.rKeyword<number, number, PacketStreamIngressTiming>;
    get filter_interval(): VScript.rKeyword<number, number, PacketStreamIngressTiming>;
    get media_clock(): _Time.Source;
}
export interface MPacket {
    extended_frc: number;
    seqnr: number;
    format: number;
}
export declare class PacketStream {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      Seqnr offset relative to other packet streams mapped to the same memory
      region. N packet streams hence define N-1 meaningful offsets.
    */
    get seqnr_offset(): VScript.rKeyword<number, number, PacketStream>;
    /**
      IP (unicast) address of the RTP stream sender
    */
    get src_address(): VScript.rKeyword<string, string, PacketStream>;
    /**
      IP (multicast) destination address of the RTP stream
    */
    get dst_address(): VScript.rKeyword<string, string, PacketStream>;
    get interface(): VScript.rKeyword<string | null, _NetworkInterfaces.VirtualInterface | null, PacketStream>;
    /**
      no. of m-packets received since the last stream start (for audio streams,
      this refers to virtual m-packets). Note that for interlaced video
      streams, this number only includes lower field m-packets, i.e., a 50i
      2110 stream should report 25 m-packets per second.
    */
    get mpackets_received(): VScript.rKeyword<number, number, PacketStream>;
    get type(): VScript.rKeyword<"Passthrough" | "Audio" | "VideoNon2022_6" | "Video2022_6" | "Video2110_40_Metadata" | "MipMap" | "J2K", "Passthrough" | "Audio" | "VideoNon2022_6" | "Video2022_6" | "Video2110_40_Metadata" | "MipMap" | "J2K", PacketStream>;
    get buffer(): VScript.rKeyword<string | null, Buffer | null, PacketStream>;
    get ingress_timing(): PacketStreamIngressTiming;
}
export declare class PacketStreamAsTableRow extends PacketStream {
    readonly enclosing_table: VScript.StronglyTypedTable<PacketStream>;
    readonly index: number;
    constructor(raw_row: VScript.TableRow, enclosing_table: VScript.StronglyTypedTable<PacketStream>);
}
export declare class NetworkSource {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get packet_stream(): VScript.rKeyword<string | null, PacketStream | null, NetworkSource>;
}
export declare class NetworkSourceAsTableRow extends NetworkSource {
    readonly enclosing_table: VScript.StronglyTypedTable<NetworkSource>;
    readonly index: number;
    constructor(raw_row: VScript.TableRow, enclosing_table: VScript.StronglyTypedTable<NetworkSource>);
}
export declare class AffineNetworkSource {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get source(): VScript.rKeyword<string | null, NetworkSource | null, AffineNetworkSource>;
    get seqnr_offset(): VScript.rKeyword<number, number, AffineNetworkSource>;
}
export declare class AffineNetworkSourceAsTableRow extends AffineNetworkSource {
    readonly enclosing_table: VScript.StronglyTypedTable<AffineNetworkSource>;
    readonly index: number;
    constructor(raw_row: VScript.TableRow, enclosing_table: VScript.StronglyTypedTable<AffineNetworkSource>);
}
export declare class VideoFlowPartition {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get id(): VScript.rKeyword<number, number, VideoFlowPartition>;
    get sdp_standard(): VScript.rKeyword<_Video.Standard, _Video.Standard, VideoFlowPartition>;
    get fmt_standard(): VScript.rKeyword<_Video.Standard, _Video.Standard, VideoFlowPartition>;
    get transport_format(): VScript.rKeyword<_Video.TransportFormat, _Video.TransportFormat, VideoFlowPartition>;
    get leader(): VScript.rKeyword<string | null, NetworkSource | null, VideoFlowPartition>;
    /**
      Network sources feeding this flow partition; if more than 8 sources feed
      into a single partition, surplus sources will not be published via the
      web interface
    */
    get auxiliary_sources(): VScript.StronglyTypedTable<AffineNetworkSource, VScript.TableRowView<AffineNetworkSource>>;
}
export declare class VideoFlowPartitionAsTableRow extends VideoFlowPartition {
    readonly enclosing_table: VScript.StronglyTypedTable<VideoFlowPartition>;
    readonly index: number;
    constructor(raw_row: VScript.TableRow, enclosing_table: VScript.StronglyTypedTable<VideoFlowPartition>);
}
export declare class AudioFlowPartition {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get id(): VScript.rKeyword<number, number, AudioFlowPartition>;
    get format(): VScript.rKeyword<_Audio.Format, _Audio.Format, AudioFlowPartition>;
    get frequency(): VScript.rKeyword<_Audio.Frequency, _Audio.Frequency, AudioFlowPartition>;
    get channelcount(): VScript.rKeyword<number, number, AudioFlowPartition>;
    get samplecount(): VScript.rKeyword<number, number, AudioFlowPartition>;
    get leader(): VScript.rKeyword<string | null, NetworkSource | null, AudioFlowPartition>;
    /**
      Network sources feeding this flow partition; if more than 8 sources feed
      into a single partition, surplus sources will not be published via the
      web interface
    */
    get auxiliary_sources(): VScript.StronglyTypedTable<AffineNetworkSource, VScript.TableRowView<AffineNetworkSource>>;
}
export declare class AudioFlowPartitionAsTableRow extends AudioFlowPartition {
    readonly enclosing_table: VScript.StronglyTypedTable<AudioFlowPartition>;
    readonly index: number;
    constructor(raw_row: VScript.TableRow, enclosing_table: VScript.StronglyTypedTable<AudioFlowPartition>);
}
export declare class PassthroughFlowPartition {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get id(): VScript.rKeyword<number, number, PassthroughFlowPartition>;
    get leader(): VScript.rKeyword<string | null, NetworkSource | null, PassthroughFlowPartition>;
    /**
      Network sources feeding this flow partition; if more than 8 sources feed
      into a single partition, surplus sources will not be published via the
      web interface
    */
    get auxiliary_sources(): VScript.StronglyTypedTable<AffineNetworkSource, VScript.TableRowView<AffineNetworkSource>>;
}
export declare class PassthroughFlowPartitionAsTableRow extends PassthroughFlowPartition {
    readonly enclosing_table: VScript.StronglyTypedTable<PassthroughFlowPartition>;
    readonly index: number;
    constructor(raw_row: VScript.TableRow, enclosing_table: VScript.StronglyTypedTable<PassthroughFlowPartition>);
}
export declare type PhaseReference = "ForeignMediaClock" | "ForeignReadDelay" | "PacketStream" | "BufferMidpoint" | "TimeSource";
export declare type UnalignedPhaseReference = "ForeignMediaClock" | "ForeignReadDelay" | "PacketStream" | "BufferMidpoint";
export declare class Timing {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get phase_reference(): VScript.duplexKeyword<PhaseReference, PhaseReference, Timing>;
    get time_source(): VScript.duplexKeyword<string | null, _Time.Source | null, Timing>;
    get foreign_receiver(): VScript.duplexKeyword<string | null, MediaReceiver | null, Timing>;
    /**
      the correct interpretation of `value` depends on `phase_reference`;
      please refer to the help section `RTPReceiver > Timing settings` for
      details
    */
    get value(): VScript.duplexKeyword<number, number, Timing>;
    /**
      the `read_delay` setting does not always take effect (e.g., it is ignored
      during phase-accurate video playout). Still, the decoder needs to
      maintain a minimum distance from the RX buffer boundaries to protect
      against over- or underflow. This minimum distance can be set using
      `safety_margin`. Note that, depending on the currently received stream
      format, a configured safety margin may not always be realizable
    */
    get safety_margin(): VScript.duplexKeyword<number, number, Timing>;
    get buffer_capacity(): VScript.rKeyword<number, number, Timing>;
    /**
      set this to `true` if you want the incoming stream's RTP timestamp to
      define its offset from the PTP/SMPTE ST 2059 epoch. For further
      information on how this flag affects stream timing, please refer to `Help
      > RTPReceiver > Timing`.
    */
    get use_rtp_timestamp(): VScript.duplexKeyword<boolean, boolean, Timing>;
    get on_backpressure(): VScript.duplexKeyword<"Yield" | "Resist", "Yield" | "Resist", Timing>;
}
export interface ErrorCounter {
    /**
      internal timestamp, initialized to zero at process startup
    */
    last_seen_at: number;
    consec_err_count: number;
    err_acc: number;
}
export declare class CurrentRedundancyLevels {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      Number of streams referenced by this receiver's SDP that are actually
      present, indexed by subflow number. The latter is typically 0, but for
      quad-link video receivers can range from 0 to 3, and is 4 for 2110-40
      flows routed into a 2110-20 video receiver.
    */
    get per_subflow(): VScript.rKeyword<[number, number, number, number, number], [number, number, number, number, number], CurrentRedundancyLevels>;
    get overall(): VScript.rKeyword<number, number, CurrentRedundancyLevels>;
}
declare class MediaReceiverIssues {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get subscription_failed(): VScript.rKeyword<boolean, boolean, MediaReceiverIssues>;
    get uncalibrated_genlock(): VScript.rKeyword<boolean, boolean, MediaReceiverIssues>;
    get uncalibrated_or_missing_time_source(): VScript.rKeyword<boolean, boolean, MediaReceiverIssues>;
    get undersized_timing_window(): VScript.rKeyword<boolean, boolean, MediaReceiverIssues>;
    get readout_request_failed(): VScript.rKeyword<boolean, boolean, MediaReceiverIssues>;
    get swap_request_failed(): VScript.rKeyword<boolean, boolean, MediaReceiverIssues>;
}
declare class MediaReceiverFlightPermit {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get denied(): VScript.rKeyword<boolean, boolean, MediaReceiverFlightPermit>;
    get remaining_patience(): VScript.rKeyword<number, number, MediaReceiverFlightPermit>;
    /**
      internal timestamp, initialized to zero at process startup
    */
    get prev_request_at(): VScript.rKeyword<number, number, MediaReceiverFlightPermit>;
}
declare class MediaReceiverErrorCounters {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get rx_error(): VScript.rKeyword<any, ErrorCounter | null, this>;
    /**
      premature read errors are signalled when the decoder attempts to process
      data that has not yet been delivered by the memory controller
    */
    get premature_read(): VScript.rKeyword<any, ErrorCounter | null, this>;
    get liveness_timeout(): VScript.rKeyword<any, ErrorCounter | null, this>;
    get phase_mismatch(): VScript.rKeyword<any, ErrorCounter | null, this>;
    get subscription_failure(): VScript.rKeyword<any, ErrorCounter | null, this>;
}
declare class MediaReceiverEventCounters {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      increased by 1 on every start attempt targeting SDP A
    */
    get start_a(): VScript.rKeyword<number, number, MediaReceiverEventCounters>;
    /**
      increased by 1 on every start attempt targeting SDP B
    */
    get start_b(): VScript.rKeyword<number, number, MediaReceiverEventCounters>;
    /**
      increased by 1 on every A → B switch attempt
    */
    get switch_ab(): VScript.rKeyword<number, number, MediaReceiverEventCounters>;
    /**
      increased by 1 on every B → A switch attempt
    */
    get switch_ba(): VScript.rKeyword<number, number, MediaReceiverEventCounters>;
    /**
      increased by 1 on every receiver stop
    */
    get stop(): VScript.rKeyword<number, number, MediaReceiverEventCounters>;
    /**
      increased by 1 on every error-induced receiver restart
    */
    get restart(): VScript.rKeyword<number, number, MediaReceiverEventCounters>;
    /**
      increased by 1 every time an accepted SDP request evicts another SDP
      currently targeted by the decoder backend
    */
    get stop_evicted(): VScript.rKeyword<number, number, MediaReceiverEventCounters>;
    /**
      BBM video receivers that have their RX buffer supplied by other
      receivers' network streams do not attempt to freeze their decoder
      backends at switch time. If these foreign streams are withdrawn before
      the BBM switch has completed, the BBM receiver's decoder backend will be
      stopped, and `stop_abandoned` will increase by 1
    */
    get stop_abandoned(): VScript.rKeyword<number, number, MediaReceiverEventCounters>;
    /**
      if, during SDP request processing, the completion of a previously issued
      start command has not been verified conclusively, the decoder backend may
      be stopped, in which case `stop_unfinished_start_attempt` will increase
      by 1
    */
    get stop_unfinished_start_attempt(): VScript.rKeyword<number, number, MediaReceiverEventCounters>;
    /**
      if `clean_switching_policy` is set to `Whatever`, impossible
      clean-switching requests are silently converted to patch requests, thus
      causing loss-of-signal events at switch time
    */
    get downgraded_switch_requests(): VScript.rKeyword<number, number, MediaReceiverEventCounters>;
    /**
      increased by 1 every time the receiver formally switches between
      identical media flows on tracks A and B
    */
    get elided_switch_requests(): VScript.rKeyword<number, number, MediaReceiverEventCounters>;
}
/**
  TODO: convert to variable-size arrays
*/
declare class MediaReceiverReadDelayPerStream {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get stream(): VScript.rKeyword<string | null, PacketStream | null, MediaReceiverReadDelayPerStream>;
    /**
      used to distinguish between a video flow's underlying video streams
      (subflows 0 to 3 for a quad-link flow, 0 otherwise), and its 2110-40
      sidecar (4), if any
    */
    get subflow_index(): VScript.rKeyword<number, number, MediaReceiverReadDelayPerStream>;
    get is_rearguard(): VScript.rKeyword<boolean, boolean, MediaReceiverReadDelayPerStream>;
    get read_delay(): VScript.rKeyword<any, _Time.TimestampedOffset | null, this>;
}
declare class MediaReceiverReadDelay {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get target_track(): VScript.rKeyword<Track, Track, MediaReceiverReadDelay>;
    get overall(): VScript.rKeyword<any, _Time.TimestampedOffset | null, this>;
    /**
      TODO: convert to variable-size arrays
    */
    get per_stream(): VScript.StronglyTypedTable<MediaReceiverReadDelayPerStream, VScript.TableRowView<MediaReceiverReadDelayPerStream>>;
}
declare class MediaReceiverRequiredRedundancyLevel {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      number of packet streams referenced by this receiver's media description
      at track A that must have been registered at their respective network
      interfaces for the receiver to attempt readout
    */
    get sdp_a(): VScript.rKeyword<number, number, MediaReceiverRequiredRedundancyLevel>;
    /**
      number of packet streams referenced by this receiver's media description
      at track B that must have been registered at their respective network
      interfaces for the receiver to attempt readout
    */
    get sdp_b(): VScript.rKeyword<number, number, MediaReceiverRequiredRedundancyLevel>;
}
declare class MediaReceiverRedundancyLevels {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get nominally_present(): CurrentRedundancyLevels;
    get within_safe_bounds(): CurrentRedundancyLevels;
}
declare class MediaReceiverLatencySpread {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get per_subflow(): VScript.rKeyword<[number, number, number, number, number], [number, number, number, number, number], MediaReceiverLatencySpread>;
    get overall(): VScript.rKeyword<number, number, MediaReceiverLatencySpread>;
}
export declare class MediaReceiver {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get state(): VScript.rKeyword<TrackControllerState, TrackControllerState, MediaReceiver>;
    get hosting_session(): VScript.duplexKeyword<string | null, Session | null, MediaReceiver>;
    /**
      Clear error counters
    */
    get clear_error_counters(): VScript.wKeyword<"Click", "Click", MediaReceiver>;
    /**
      Clear event counters
    */
    get clear_event_counters(): VScript.wKeyword<"Click", "Click", MediaReceiver>;
    get preparation_time(): VScript.duplexKeyword<number, number, MediaReceiver>;
    get cooldown_time(): VScript.duplexKeyword<number, number, MediaReceiver>;
    get current_target(): VScript.rKeyword<Track, Track, MediaReceiver>;
    get next_target(): VScript.rKeyword<Track, Track, MediaReceiver>;
    /**
      when set to `FirstStreamPresent`, the first packet stream to provide this
      receiver with valid format and timing characteristics will be used as the
      basis for the ensuing readout attempt. When set to `AllStreamsPresent`,
      the receiver will stall until all packet streams have been registered at
      their respective network interfaces. Whereas `FirstStreamPresent` may
      slightly reduce the time to readout, `AllStreamsPresent` is safer as it
      ensures immediate SPS protection (if so configured), and allows the
      receiver to correctly pick a rearguard stream if different network paths
      exhibit different transmission delays. In both cases, the set of packet
      streams considered encompasses only those flows directly referenced by
      this receiver's media description, not the auxiliary flows that may be
      routed to the receiver through stream sharing.
    */
    get initiate_readout_on(): VScript.rwKeyword<"FirstStreamPresent" | "AllStreamsPresent", "FirstStreamPresent" | "AllStreamsPresent", MediaReceiver>;
    get ingress(): Ingress;
    get egress(): Egress;
    get expecting(): Expectations;
    get issues(): MediaReceiverIssues;
    get flight_permit(): MediaReceiverFlightPermit;
    get error_counters(): MediaReceiverErrorCounters;
    get event_counters(): MediaReceiverEventCounters;
    get timing(): Timing;
    get current_phase(): _Time.Source;
    get read_delay(): MediaReceiverReadDelay;
    get required_redundancy_level(): MediaReceiverRequiredRedundancyLevel;
    get redundancy_levels(): MediaReceiverRedundancyLevels;
    get latency_spread(): MediaReceiverLatencySpread;
}
export declare class AudioServo {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get relative_speed(): VScript.rKeyword<number, number, AudioServo>;
    get max_relative_speed(): VScript.rwKeyword<number, number, AudioServo>;
    get max_acceleration(): VScript.rwKeyword<number, number, AudioServo>;
    get prioritize(): VScript.rKeyword<"Quality" | "Responsiveness", "Quality" | "Responsiveness", AudioServo>;
}
export declare class AudioServoAsArrayRow<ParentType extends VScript.StronglyTypedSubtree> extends AudioServo {
    readonly index: number;
    readonly parent: ParentType;
    constructor(st: VScript.Subtree, index: number, parent: ParentType);
}
export declare type ReadSpeed = "LockToGenlock" | "Adaptive";
declare class AudioReceiverAudioSpecificFlowPartitions {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get sdp_a(): VScript.rKeyword<string | null, AudioFlowPartition | null, AudioReceiverAudioSpecificFlowPartitions>;
    get sdp_b(): VScript.rKeyword<string | null, AudioFlowPartition | null, AudioReceiverAudioSpecificFlowPartitions>;
}
declare class AudioReceiverAudioSpecificOutput {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get audio(): _Audio.Essence;
    get ptp_traits(): _PTP.Traits;
}
declare class AudioReceiverAudioSpecific {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get channel_capacity(): VScript.duplexKeyword<number, number, AudioReceiverAudioSpecific>;
    get read_speed(): VScript.duplexKeyword<ReadSpeed, ReadSpeed, AudioReceiverAudioSpecific>;
    get servo(): VScript.rKeyword<string | null, AudioServo | null, AudioReceiverAudioSpecific>;
    get permit_jumps(): VScript.duplexKeyword<boolean, boolean, AudioReceiverAudioSpecific>;
    get decoder_index(): VScript.rKeyword<number, number, AudioReceiverAudioSpecific>;
    get flow_partitions(): AudioReceiverAudioSpecificFlowPartitions;
    get output(): AudioReceiverAudioSpecificOutput;
}
export declare class AudioReceiver {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get generic(): MediaReceiver;
    get audio_specific(): AudioReceiverAudioSpecific;
}
export declare class AudioReceiverAsNamedTableRow extends AudioReceiver {
    private readonly raw_row;
    readonly enclosing_table: VScript.StronglyTypedNamedTable<AudioReceiver>;
    readonly index: number;
    constructor(raw_row: VScript.NamedTableRow, enclosing_table: VScript.StronglyTypedNamedTable<AudioReceiver>);
    rename(name: string, opts?: VScript.CommonWriteOptions): Promise<void>;
    delete(opts?: VScript.CommonWriteOptions): Promise<void>;
}
export declare class PassthroughEssence {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get brief(): VScript.rKeyword<string, string, PassthroughEssence>;
    get stream_id(): VScript.rKeyword<number, number, PassthroughEssence>;
    get memory_blocks(): VScript.rKeyword<[number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number], [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number], PassthroughEssence>;
    get sdp(): VScript.rKeyword<string, string, PassthroughEssence>;
}
declare class PassthroughReceiverEgress {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get track(): VScript.rKeyword<Track, Track, PassthroughReceiverEgress>;
}
declare class PassthroughReceiverIssues {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get subscription_failed(): VScript.rKeyword<boolean, boolean, PassthroughReceiverIssues>;
}
declare class PassthroughReceiverFlowPartitions {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get sdp_a(): VScript.rKeyword<string | null, PassthroughFlowPartition | null, PassthroughReceiverFlowPartitions>;
    get sdp_b(): VScript.rKeyword<string | null, PassthroughFlowPartition | null, PassthroughReceiverFlowPartitions>;
}
export declare class PassthroughReceiver {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get state(): VScript.rKeyword<TrackControllerState, TrackControllerState, PassthroughReceiver>;
    get hosting_session(): VScript.duplexKeyword<string | null, Session | null, PassthroughReceiver>;
    get current_target(): VScript.rKeyword<Track, Track, PassthroughReceiver>;
    get next_target(): VScript.rKeyword<Track, Track, PassthroughReceiver>;
    get ingress(): Ingress;
    get egress(): PassthroughReceiverEgress;
    get issues(): PassthroughReceiverIssues;
    get output(): PassthroughEssence;
    get flow_partitions(): PassthroughReceiverFlowPartitions;
}
export declare class PassthroughReceiverAsNamedTableRow extends PassthroughReceiver {
    private readonly raw_row;
    readonly enclosing_table: VScript.StronglyTypedNamedTable<PassthroughReceiver>;
    readonly index: number;
    constructor(raw_row: VScript.NamedTableRow, enclosing_table: VScript.StronglyTypedNamedTable<PassthroughReceiver>);
    rename(name: string, opts?: VScript.CommonWriteOptions): Promise<void>;
    delete(opts?: VScript.CommonWriteOptions): Promise<void>;
}
export declare class VideoServo {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get relative_speed(): VScript.rKeyword<number, number, VideoServo>;
    get max_relative_speed(): VScript.rwKeyword<number, number, VideoServo>;
    get max_acceleration(): VScript.rwKeyword<number, number, VideoServo>;
}
export declare class VideoServoAsArrayRow<ParentType extends VScript.StronglyTypedSubtree> extends VideoServo {
    readonly index: number;
    readonly parent: ParentType;
    constructor(st: VScript.Subtree, index: number, parent: ParentType);
}
export interface SoftMetadataStatistics {
    packets_received: number;
    discarded_obsolete: number;
    parse_errors: number;
    type_unknown: number;
    parsed_as_empty_cea708: number;
    parsed_as_proper_cea708: number;
    parsed_as_empty_op47: number;
    parsed_as_proper_op47: number;
    parsed_as_empty_st12: number;
    parsed_as_proper_st12: number;
}
declare class AncBurstReceiverMediaClock {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get ingress(): _Time.Source;
    get egress(): _Time.Source;
}
export declare class AncBurstReceiver {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get generic(): MediaReceiver;
    get media_clock(): AncBurstReceiverMediaClock;
}
export declare class AncBurstReceiverAsNamedTableRow extends AncBurstReceiver {
    private readonly raw_row;
    readonly enclosing_table: VScript.StronglyTypedNamedTable<AncBurstReceiver>;
    readonly index: number;
    constructor(raw_row: VScript.NamedTableRow, enclosing_table: VScript.StronglyTypedNamedTable<AncBurstReceiver>);
    rename(name: string, opts?: VScript.CommonWriteOptions): Promise<void>;
    delete(opts?: VScript.CommonWriteOptions): Promise<void>;
}
declare class VideoReceiverVideoSpecificCapabilities {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get operational(): VScript.rKeyword<boolean, boolean, VideoReceiverVideoSpecificCapabilities>;
    get supports_st_2042(): VScript.duplexKeyword<boolean, boolean, VideoReceiverVideoSpecificCapabilities>;
    get supports_uhd_2110_singlelink(): VScript.duplexKeyword<boolean, boolean, VideoReceiverVideoSpecificCapabilities>;
    get supports_uhd_sample_interleaved(): VScript.duplexKeyword<boolean, boolean, VideoReceiverVideoSpecificCapabilities>;
    get supports_2110_40_reception(): VScript.rKeyword<boolean, boolean, VideoReceiverVideoSpecificCapabilities>;
    get main_decoder_index(): VScript.rKeyword<number, number, VideoReceiverVideoSpecificCapabilities>;
}
declare class VideoReceiverVideoSpecificErrorCounters {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get mpacket_error(): VScript.rKeyword<any, ErrorCounter | null, this>;
    get offset_2110_error(): VScript.rKeyword<any, ErrorCounter | null, this>;
    get linenr_2110_error(): VScript.rKeyword<any, ErrorCounter | null, this>;
}
declare class VideoReceiverVideoSpecificEventCounters {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get frame_drop_events(): VScript.rKeyword<number, number, VideoReceiverVideoSpecificEventCounters>;
    get frame_repeat_events(): VScript.rKeyword<number, number, VideoReceiverVideoSpecificEventCounters>;
    /**
      if a flow used by a frozen BBM-mode video receiver is reactivated by
      another receiver's subscription request, the frozen receiver must attempt
      to unfreeze its signal to preserve signal integrity
    */
    get forced_unfreeze_events(): VScript.rKeyword<number, number, VideoReceiverVideoSpecificEventCounters>;
}
declare class VideoReceiverVideoSpecificFlowPartitions {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get sdp_a(): VScript.rKeyword<string | null, VideoFlowPartition | null, VideoReceiverVideoSpecificFlowPartitions>;
    get sdp_b(): VScript.rKeyword<string | null, VideoFlowPartition | null, VideoReceiverVideoSpecificFlowPartitions>;
}
declare class VideoReceiverVideoSpecificOutput {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get cc_channel(): VScript.duplexKeyword<_Video.ClosedCaptionChannel, _Video.ClosedCaptionChannel, VideoReceiverVideoSpecificOutput>;
    get video(): _Video.Essence;
    get time(): _Time.Source;
    get cc(): _Video.ClosedCaption;
    get deembedded_audio(): VScript.StronglyTypedTable<_Audio.Essence, VScript.TableRowView<_Audio.Essence>>;
    get ptp_traits(): _PTP.Traits;
}
interface VideoReceiverVideoSpecificMetadataDecoderCounters {
    num_relocations: number;
    num_embedded_packets: number;
    fc: number;
    micro_epoch_index: number;
}
declare class VideoReceiverVideoSpecificMetadataDecoder {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get state(): VScript.rKeyword<IngressTrackState, IngressTrackState, VideoReceiverVideoSpecificMetadataDecoder>;
    get counters(): VScript.rKeyword<any, VideoReceiverVideoSpecificMetadataDecoderCounters | null, this>;
    get soft_metadata_statistics(): VScript.rKeyword<any, SoftMetadataStatistics | null, this>;
}
declare class VideoReceiverVideoSpecific {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get frame_shift_policy(): VScript.duplexKeyword<FrameShiftPolicy, FrameShiftPolicy, VideoReceiverVideoSpecific>;
    get read_speed(): VScript.duplexKeyword<ReadSpeed, ReadSpeed, VideoReceiverVideoSpecific>;
    get servo(): VScript.rKeyword<string | null, VideoServo | null, VideoReceiverVideoSpecific>;
    /**
      when this is set to true, a timestamped CRC32 signature of every emitted
      video frame will be published via `signature`
    */
    get publish_signature(): VScript.rwKeyword<boolean, boolean, VideoReceiverVideoSpecific>;
    get signature(): VScript.rKeyword<any, _Video.TimestampedSignature | null, this>;
    get restrict_extractor_to(): VScript.rwKeyword<_Video.ClosedCaptionMode, _Video.ClosedCaptionMode, VideoReceiverVideoSpecific>;
    get capabilities(): VideoReceiverVideoSpecificCapabilities;
    get error_counters(): VideoReceiverVideoSpecificErrorCounters;
    get event_counters(): VideoReceiverVideoSpecificEventCounters;
    get flow_partitions(): VideoReceiverVideoSpecificFlowPartitions;
    get output(): VideoReceiverVideoSpecificOutput;
    get metadata_decoder(): VideoReceiverVideoSpecificMetadataDecoder;
    get metadata_extractor(): VScript.StronglyTypedTable<_MetadataProcessor.MetadataExtractor, VScript.TableRowView<_MetadataProcessor.MetadataExtractor>>;
}
export declare class VideoReceiver {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get generic(): MediaReceiver;
    get video_specific(): VideoReceiverVideoSpecific;
}
export declare class VideoReceiverAsNamedTableRow extends VideoReceiver {
    private readonly raw_row;
    readonly enclosing_table: VScript.StronglyTypedNamedTable<VideoReceiver>;
    readonly index: number;
    constructor(raw_row: VScript.NamedTableRow, enclosing_table: VScript.StronglyTypedNamedTable<VideoReceiver>);
    rename(name: string, opts?: VScript.CommonWriteOptions): Promise<void>;
    delete(opts?: VScript.CommonWriteOptions): Promise<void>;
}
declare class SessionSwitchCapability {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get supports_dts_bbm(): VScript.rKeyword<boolean, boolean, SessionSwitchCapability>;
    get supports_dts_mbb(): VScript.rKeyword<boolean, boolean, SessionSwitchCapability>;
    get supports_sts(): VScript.rKeyword<boolean, boolean, SessionSwitchCapability>;
}
declare class SessionVideoReceivers {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      TODO: implement table[] of ref, get rid of enclosing struct level
    */
    get wrapped_reference(): VScript.rKeyword<string | null, VideoReceiver | null, SessionVideoReceivers>;
}
declare class SessionAudioReceivers {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      TODO: implement table[] of ref, get rid of enclosing struct level
    */
    get wrapped_reference(): VScript.rKeyword<string | null, AudioReceiver | null, SessionAudioReceivers>;
}
declare class SessionAncBurstReceivers {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      TODO: implement table[] of ref, get rid of enclosing struct level
    */
    get wrapped_reference(): VScript.rKeyword<string | null, AncBurstReceiver | null, SessionAncBurstReceivers>;
}
declare class SessionPassthroughReceivers {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      TODO: implement table[] of ref, get rid of enclosing struct level
    */
    get wrapped_reference(): VScript.rKeyword<string | null, PassthroughReceiver | null, SessionPassthroughReceivers>;
}
declare class SessionInterfaces {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get primary(): VScript.duplexKeyword<string | null, _NetworkInterfaces.VirtualInterface | null, SessionInterfaces>;
    get secondary(): VScript.duplexKeyword<string | null, _NetworkInterfaces.VirtualInterface | null, SessionInterfaces>;
}
declare class SessionEventCountersNumRejectedSdps {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      increased by 1 every time a SDP command sent to track A is rejected
    */
    get sdp_a(): VScript.rKeyword<number, number, SessionEventCountersNumRejectedSdps>;
    /**
      increased by 1 every time a SDP command sent to track B is rejected
    */
    get sdp_b(): VScript.rKeyword<number, number, SessionEventCountersNumRejectedSdps>;
}
declare class SessionEventCounters {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get num_rejected_sdps(): SessionEventCountersNumRejectedSdps;
}
declare class SessionVersionWindow {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      Reject incoming SDPs unless their version (specified using a
      session-level `a=controller-version:` attribute) exceeds the most
      recently accepted version by at least this much, using cyclic 32-bit
      arithmetic
    */
    get min_delta(): VScript.duplexKeyword<number, number, SessionVersionWindow>;
    /**
      Reject incoming SDPs unless their version (specified using a
      session-level `a=controller-version:` attribute) exceeds the most
      recently accepted version by no more than this much, using cyclic 32-bit
      arithmetic
    */
    get max_delta(): VScript.duplexKeyword<number, number, SessionVersionWindow>;
}
interface SessionLastAcceptedTrack {
    track: Track;
    fc: number;
    controller_version: number;
    /**
      Currently set to all zeroes if the given SDP does not specify a
      `controller-id`; in version 2.0 this will be replaced by a proper
      optional.
    */
    controller_id: [
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number,
        number
    ];
}
export declare class Session {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get alert_level(): VScript.rKeyword<_Primitives.AlertLevel, _Primitives.AlertLevel, Session>;
    get switch_time(): VScript.duplexKeyword<string | number, string | number, Session>;
    get switch_type(): VScript.duplexKeyword<SwitchType, SwitchType, Session>;
    get active(): VScript.duplexKeyword<boolean, boolean, Session>;
    get sdp_a(): VScript.duplexKeyword<string, string, Session>;
    get sdp_b(): VScript.duplexKeyword<string, string, Session>;
    get session_state(): VScript.rKeyword<TrackControllerState, TrackControllerState, Session>;
    get last_accepted_track(): VScript.rKeyword<any, SessionLastAcceptedTrack | null, this>;
    get switch_capability(): SessionSwitchCapability;
    get video_receivers(): VScript.StronglyTypedTable<SessionVideoReceivers, VScript.TableRowView<SessionVideoReceivers>>;
    get audio_receivers(): VScript.StronglyTypedTable<SessionAudioReceivers, VScript.TableRowView<SessionAudioReceivers>>;
    get anc_burst_receivers(): VScript.StronglyTypedTable<SessionAncBurstReceivers, VScript.TableRowView<SessionAncBurstReceivers>>;
    get passthrough_receivers(): VScript.StronglyTypedTable<SessionPassthroughReceivers, VScript.TableRowView<SessionPassthroughReceivers>>;
    get interfaces(): SessionInterfaces;
    get event_counters(): SessionEventCounters;
    get version_window(): SessionVersionWindow;
}
export declare class SessionAsNamedTableRow extends Session {
    private readonly raw_row;
    readonly enclosing_table: VScript.StronglyTypedNamedTable<Session>;
    readonly index: number;
    constructor(raw_row: VScript.NamedTableRow, enclosing_table: VScript.StronglyTypedNamedTable<Session>);
    rename(name: string, opts?: VScript.CommonWriteOptions): Promise<void>;
    delete(opts?: VScript.CommonWriteOptions): Promise<void>;
}
export declare type ErrorCondition = "RXErrors" | "PrematureRead" | "LivenessTimeout" | "PhaseMismatch" | "MPacketError" | "OffsetError2110" | "LinenrError2110";
/**
  some configuration attempts cannot be executed completely. For example, a
  session containing 3 audio receivers will not be able to service a
  connection request if the corresponding SDP contains 4 or more audio
  essences. In these cases, the receiver may either set up as many
  connections as possible and discard the rest (`BestEffort`), or refuse the
  configuration attempt and raise an error message instead (`Refuse`).
*/
export declare type ResourceExhaustionPolicy = "Refuse" | "BestEffort";
/**
  SMPTE 2022-6 video streams should advertise their video format within the
  m-packet header. Additionally, the video format may be specified in advance
  using the `fmtp` SDP attribute (for SMPTE 2110 and ST 2042 streams, this is
  the only way to specify video standards). Should the standard extracted
  from an incoming m-packet disagree with a previously specified `fmtp`
  attribute, this setting determines which one takes precedence.
*/
export declare type VidStd20226Authority = "SDPFmtpAttribute" | "MPacketMetadata";
/**
  depending on the relative offset between incoming streams and the selected
  reference time source, a stream receiver may not be able to establish the
  user-configured phase offset (unless the RX buffer is large enough to
  contain at least one full video frame). If a receiver is unable to provide
  the requested phase relation, it may either stop (`AbortOperation`) or
  readjust the phase to match RX buffer capacity (`ChangePhase`).
*/
export declare type PhaseConflictHandler = "AbortOperation" | "ChangePhase";
/**
  if `clean_switching_policy` is set to `Tolerant`, packet rates and ST2042
  compression ratios may change across switching boundaries. This ensures
  interoperability between a wider range of transmitters but comes at a
  slight performance penalty, as the receiver first has to determine the
  current packet rate before a switch can be effected. When set to
  `Whatever`, impossible clean switching requests will silently be converted
  into patching operations. Please only use this option as a measure of last
  resort, if at all.
*/
export declare type CleanSwitchingPolicy = "Strict" | "Tolerant" | "Whatever";
export interface MPacketDebugInfo {
    packet_stream_index: number;
    m_flag: boolean;
    seqnr: number;
    last_word: number;
    empty: number;
    rtp_timestamp: number;
    frc: number;
    misc: number;
}
declare class AllDiagnostics {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      if RAM calibration failed and rebooting does not fix the issue, please
      contact customer support
    */
    get ram_calibration(): VScript.rKeyword<"Unknown" | "Successful" | "Failed", "Unknown" | "Successful" | "Failed", AllDiagnostics>;
    /**
      log incoming packets for approximately this long. Note that this may
      cause noticeable processing overhead
    */
    get mpacket_log_request(): VScript.wKeyword<number, number, AllDiagnostics>;
    get keep_logging_for(): VScript.rKeyword<number, number, AllDiagnostics>;
    get prev_mpacket(): VScript.rKeyword<any, MPacketDebugInfo | null, this>;
    get metadata_channel(): VScript.rKeyword<_MetadataProcessor.RTPChannelStatus, _MetadataProcessor.RTPChannelStatus, AllDiagnostics>;
    get memory_statistics(): _Memory.ECCMuxStatistics;
    get rtp_input(): VScript.StronglyTypedArray<AllDiagnostics, RTPInputStatistics, VScript.RowView<RTPInputStatistics>>;
}
/**
  if `on_phase_mismatch` is set to `RestartReceiver`, the receiver will
  correct a misaligned output phase (i.e., a phase that deviates from the
  chosen reference by more than `tolerance`) by restarting its video output.
  Note that this causes intermittent loss-of-signal events. Whenever possible
  (i.e., if drop/repeat frames improve on the current timing situation, or if
  a reserve Audio decoder is available), the receiver may also decide to
  initiate corrective jumps instead of full receiver restarts
*/
declare class AllSettingsPhaseMismatch {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      only permit corrective jumps after this many consecutive `phase_mismatch`
      errors
    */
    get jump_threshold(): VScript.rwKeyword<number, number, AllSettingsPhaseMismatch>;
    /**
      only permit restarts after this many consecutive `phase_mismatch` errors
    */
    get threshold(): VScript.rwKeyword<number, number, AllSettingsPhaseMismatch>;
    /**
      a nonzero value of `current_phase.value` is considered a phase mismatch
      if and only if its absolute value exceeds both `relative_tolerance` ×
      `current_phase.error` and `abs_tolerance`
    */
    get relative_tolerance(): VScript.rwKeyword<number, number, AllSettingsPhaseMismatch>;
    /**
      a nonzero value of `current_phase.value` is considered a phase mismatch
      if and only if its absolute value exceeds both `relative_tolerance` ×
      `current_phase.error` and `abs_tolerance`
    */
    get abs_tolerance(): VScript.rwKeyword<number, number, AllSettingsPhaseMismatch>;
    /**
      during stream initialization (i.e., shortly after initial playout or
      after patching to a new SDP), brief loss-of-signal events are typically
      noncritical. The RTP receiver will thus act as if `above_threshold_do`
      were set to `RestartReceiver` if the time elapsed since the last
      playout/patching operation is no greater than `init_phase_duration`. This
      accelerates clock recovery for strongly asynchronous streams, at the
      expense of some initial flickering. To disable this behavior, set
      `init_phase_duration` to `0s` (but note that even when active, this
      option does not affect clean-switching operations)
    */
    get init_phase_duration(): VScript.duplexKeyword<number, number, AllSettingsPhaseMismatch>;
    get above_threshold_do(): VScript.rwKeyword<ErrorHandler, ErrorHandler, AllSettingsPhaseMismatch>;
}
declare class AllSettings {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    /**
      if `clean_switching_policy` is set to `Tolerant`, packet rates and ST2042
      compression ratios may change across switching boundaries. This ensures
      interoperability between a wider range of transmitters but comes at a
      slight performance penalty, as the receiver first has to determine the
      current packet rate before a switch can be effected. When set to
      `Whatever`, impossible clean switching requests will silently be
      converted into patching operations. Please only use this option as a
      measure of last resort, if at all.
    */
    get clean_switching_policy(): VScript.rwKeyword<CleanSwitchingPolicy, CleanSwitchingPolicy, AllSettings>;
    /**
      set this to modern to have generated 2042-raw/2022-6 streams state their
      respective rtp clock rates
    */
    get sdp_format(): VScript.rwKeyword<_SDP.SDPFormat, _SDP.SDPFormat, AllSettings>;
    /**
      determines how SDP files entered into `sdp_a_command` or `sdp_b_command`
      translate into their respective `status` counterparts. If
      `sdp_generation` is set to `Verbatim`, accepted SDP files are copied to
      `status` unmodified, even if some or all of the media descriptions within
      could not be serviced due to resource exhaustion. If `sdp_generation` is
      set to `Semantic`, only operationally effective parts of the SDP will be
      emitted.
    */
    get sdp_generation(): VScript.rwKeyword<"Semantic" | "Verbatim", "Semantic" | "Verbatim", AllSettings>;
    get num_audio_reserve_receivers(): VScript.duplexKeyword<number, number, AllSettings>;
    /**
      time after which countable error events (such as RX errors or m-packet
      errors) are automatically cleared. Error accumulators are left unchanged
      until cleared explicitly by the user
    */
    get error_signalling_timeout(): VScript.duplexKeyword<number, number, AllSettings>;
    /**
      TODO
    */
    get flight_permit_timeout(): VScript.duplexKeyword<number, number, AllSettings>;
    /**
      SMPTE 2022-6 video streams should advertise their video format within the
      m-packet header. Additionally, the video format may be specified in
      advance using the `fmtp` SDP attribute (for SMPTE 2110 and ST 2042
      streams, this is the only way to specify video standards). Should the
      standard extracted from an incoming m-packet disagree with a previously
      specified `fmtp` attribute, this setting determines which one takes
      precedence.
    */
    get who_determines_2022_6_standards(): VScript.rwKeyword<VidStd20226Authority, VidStd20226Authority, AllSettings>;
    /**
      when in clean-switching mode (i.e., if `switch_time` is neither 0 nor 1),
      SDP writes to `current_target` are rejected, followed by an informational
      error message. Set `on_sdp_collision` to `RejectSilently` to suppress
      this error message.
    */
    get on_sdp_collision(): VScript.rwKeyword<"RejectAndInform" | "RejectSilently", "RejectAndInform" | "RejectSilently", AllSettings>;
    /**
      some configuration attempts cannot be executed completely. For example, a
      session containing 3 audio receivers will not be able to service a
      connection request if the corresponding SDP contains 4 or more audio
      essences. In these cases, the receiver may either set up as many
      connections as possible and discard the rest (`BestEffort`), or refuse
      the configuration attempt and raise an error message instead (`Refuse`).
    */
    get exhaustion_policy(): VScript.rwKeyword<ResourceExhaustionPolicy, ResourceExhaustionPolicy, AllSettings>;
    /**
      depending on the relative offset between incoming streams and the
      selected reference time source, a stream receiver may not be able to
      establish the user-configured phase offset (unless the RX buffer is large
      enough to contain at least one full video frame). If a receiver is unable
      to provide the requested phase relation, it may either stop
      (`AbortOperation`) or readjust the phase to match RX buffer capacity
      (`ChangePhase`).
    */
    get on_phase_conflict(): VScript.rwKeyword<PhaseConflictHandler, PhaseConflictHandler, AllSettings>;
    /**
      Some receiver capabilities, such as single-link 12G reception, or ST2042
      decoding, require dedicated hardware resources that may already be
      occupied by other receivers at the time a configuration request is
      made.
      
      In those cases, the system may strip other receivers of their currently
      allocated hardware resources, given that (i) `strip_mining` is not set to
      `Prohibit`, and given that those other receivers are (ii) not currently
      bound to a session or (iii) bound to the same session as the receiver
      currently being reconfigured (in which case the session must be
      inactive), and `strip_mining` is set to `WithinSameSession`.
      
      Among the set of receivers eligible for strip mining, mining targets will
      be selected in the following order:
      
      (i) if the configuration request can be fulfilled without changing other
      receivers' capabilities, do so
      
      (ii) if, among two potential mining targets, one is bound to a session
      and the other is not, strip the unbound receiver
      
      (iii) if, among two potential mining targets, both or none are
      session-bound, strip the one with the lower requested caliber, where
      calibers are ordered as follows: [12G, ST2042] > [12G, no ST2042] > [no
      12G, ST2042] > [no 12G, no ST2042].
    */
    get strip_mining(): VScript.rwKeyword<"Prohibit" | "WithinFreePoolOnly" | "WithinSameSession", "Prohibit" | "WithinFreePoolOnly" | "WithinSameSession", AllSettings>;
    get rx_error(): CountableErrorHandler;
    get mpacket_error(): CountableErrorHandler;
    get offset_2110_error(): CountableErrorHandler;
    get linenr_2110_error(): CountableErrorHandler;
    /**
      if `on_phase_mismatch` is set to `RestartReceiver`, the receiver will
      correct a misaligned output phase (i.e., a phase that deviates from the
      chosen reference by more than `tolerance`) by restarting its video
      output. Note that this causes intermittent loss-of-signal events.
      Whenever possible (i.e., if drop/repeat frames improve on the current
      timing situation, or if a reserve Audio decoder is available), the
      receiver may also decide to initiate corrective jumps instead of full
      receiver restarts
    */
    get phase_mismatch(): AllSettingsPhaseMismatch;
    get backend_liveness(): CountableErrorHandler;
    get premature_read(): CountableErrorHandler;
}
declare class AllDerivedPtpTraits {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get packet_stream_media_clock(): _PTP.Traits;
    get video_sof(): _PTP.Traits;
}
export declare class All {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get diagnostics(): AllDiagnostics;
    get settings(): AllSettings;
    get sessions(): VScript.StronglyTypedNamedTable<Session, VScript.NamedTableRowView<Session>>;
    get audio_receivers(): VScript.StronglyTypedNamedTable<AudioReceiver, VScript.NamedTableRowView<AudioReceiver>>;
    get passthrough_receivers(): VScript.StronglyTypedNamedTable<PassthroughReceiver, VScript.NamedTableRowView<PassthroughReceiver>>;
    get video_receivers(): VScript.StronglyTypedNamedTable<VideoReceiver, VScript.NamedTableRowView<VideoReceiver>>;
    get anc_burst_receivers(): VScript.StronglyTypedNamedTable<AncBurstReceiver, VScript.NamedTableRowView<AncBurstReceiver>>;
    get audio_source_slices(): VScript.StronglyTypedArray<All, _Audio.SignalSourceSlice, VScript.RowView<_Audio.SignalSourceSlice>>;
    get packet_streams(): VScript.StronglyTypedTable<PacketStream, VScript.TableRowView<PacketStream>>;
    get network_sources(): VScript.StronglyTypedTable<NetworkSource, VScript.TableRowView<NetworkSource>>;
    get audio_flow_partitions(): VScript.StronglyTypedTable<AudioFlowPartition, VScript.TableRowView<AudioFlowPartition>>;
    get passthrough_flow_partitions(): VScript.StronglyTypedTable<PassthroughFlowPartition, VScript.TableRowView<PassthroughFlowPartition>>;
    get video_flow_partitions(): VScript.StronglyTypedTable<VideoFlowPartition, VScript.TableRowView<VideoFlowPartition>>;
    get audio_buffers(): VScript.StronglyTypedTable<Buffer, VScript.TableRowView<Buffer>>;
    get passthrough_buffers(): VScript.StronglyTypedTable<Buffer, VScript.TableRowView<Buffer>>;
    get video_buffers(): VScript.StronglyTypedTable<Buffer, VScript.TableRowView<Buffer>>;
    get metadata_buffers(): VScript.StronglyTypedTable<Buffer, VScript.TableRowView<Buffer>>;
    get deembedded_audio_source_slices(): VScript.StronglyTypedArray<All, _Audio.SignalSourceSlice, VScript.RowView<_Audio.SignalSourceSlice>>;
    get derived_ptp_traits(): AllDerivedPtpTraits;
    get audio_servos(): VScript.StronglyTypedArray<All, AudioServo, VScript.RowView<AudioServo>>;
    get video_servos(): VScript.StronglyTypedArray<All, VideoServo, VScript.RowView<VideoServo>>;
}
export declare const Enums: {
    readonly CleanSwitchingPolicy: CleanSwitchingPolicy[];
    readonly PhaseConflictHandler: PhaseConflictHandler[];
    readonly VidStd20226Authority: VidStd20226Authority[];
    readonly ResourceExhaustionPolicy: ResourceExhaustionPolicy[];
    readonly ErrorCondition: ErrorCondition[];
    readonly ReadSpeed: ReadSpeed[];
    readonly UnalignedPhaseReference: UnalignedPhaseReference[];
    readonly PhaseReference: PhaseReference[];
    readonly LogicalSwitchTime: LogicalSwitchTime[];
    readonly FrameShiftPolicy: FrameShiftPolicy[];
    readonly SwitchType: SwitchType[];
    readonly EgressState: IngressTrackState[];
    readonly IngressTrackState: IngressTrackState[];
    readonly Track: Track[];
    readonly TrackControllerState: TrackControllerState[];
    readonly MediaReceiverType: MediaReceiverType[];
    readonly ErrorHandler: ErrorHandler[];
    readonly SamplingStructure: SamplingStructure[];
};
export {};
