@norskvideo/norsk-sdk 0.0.322

package/dist/norsk-sdk.d.ts

@@ -0,0 +1,2412 @@
+import { AudioCodec } from '@norskvideo/norsk-api/lib/media_pb';
+import { Context } from '@norskvideo/norsk-api/lib/media_pb';
+import { CurrentLoad } from '@norskvideo/norsk-api/lib/shared/common_pb';
+import { ExplicitChannel } from '@norskvideo/norsk-api/lib/media_pb';
+import * as grpc from '@grpc/grpc-js';
+import { HlsAudioMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsMasterMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsMasterPushMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsOutputEvent } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsTsAudioMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsTsAudioPushMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsTsCombinedPushMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsTsVideoMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsTsVideoPushMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsVideoMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsWebVttMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsWebVttPushMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { MediaClient } from '@norskvideo/norsk-api/lib/media_grpc_pb';
+import { Nullable } from 'typescript-nullable';
+import { PlainMessage } from '@bufbuild/protobuf';
+import { StreamKey as StreamKey_2 } from '@norskvideo/norsk-api/lib/media_pb';
+import { StreamStatsSampling } from '@norskvideo/norsk-api/lib/media_pb';
+import { Subscription } from '@norskvideo/norsk-api/lib/media_pb';
+import { TimestampProgramNudge } from '@norskvideo/norsk-api/lib/media_pb';
+import { TsFileInputMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { TsInputEvent } from '@norskvideo/norsk-api/lib/media_pb';
+import { UdpTsInputMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { Version } from '@norskvideo/norsk-api/lib/shared/common_pb';
+import { Wave } from '@norskvideo/norsk-api/lib/media_pb';
+
+/** @public */
+export declare type AacProfile = "lc" | "main" | "high";
+
+/** @public */
+export declare interface AacSettings {
+    kind: "aac";
+    sampleRate: SampleRate;
+    profile: AacProfile;
+}
+
+/**
+ * @public
+ * {@link NorskTransform.audioBuildMultichannel}
+ */
+export declare class AudioBuildMultichannelNode extends AutoProcessorMediaNode<"audio"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface AudioBuildMultichannelSettings extends ProcessorNodeSettings<AudioBuildMultichannelNode> {
+    channelLayout: ChannelLayout;
+    channelList: readonly StreamKey[];
+    outputStreamKey: StreamKey;
+}
+
+export { AudioCodec }
+
+/**
+ * @public
+ * {@link NorskTransform.audioEncoder}
+ */
+export declare class AudioEncoderNode extends AutoProcessorMediaNode<"audio"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface AudioEncoderSettings extends ProcessorNodeSettings<AudioEncoderNode> {
+    channelLayout: ChannelLayout;
+    bitrate: number;
+    outputRenditionName: string;
+    codec: OpusSettings | AacSettings;
+}
+
+/**
+ * @public
+ * {@link NorskTransform.audioGain}
+ */
+export declare class AudioGainNode extends AutoProcessorMediaNode<"audio"> {
+    updateConfig(settings: AudioGainSettingsUpdate): void;
+    close(): void;
+}
+
+/** @public */
+export declare interface AudioGainSettings extends ProcessorNodeSettings<AudioGainNode> {
+    /** A vector of gains for this source, one for each channel */
+    channelGains: readonly Gain[];
+}
+
+/** @public */
+export declare interface AudioGainSettingsUpdate {
+    /** A vector of gains for this source, one for each channel */
+    channelGains?: readonly Gain[];
+}
+
+/** @public */
+export declare interface AudioLevels {
+    stream: StreamKey;
+    pts: Interval;
+    channelLevels: ChannelLevels[];
+}
+
+/**
+ * @public
+ * Monitor audio levels. Create a new instance of this node with {@link NorskControl.audioLevels}.
+ */
+export declare class AudioLevelsNode extends AutoProcessorMediaNode<"audio"> {
+    close(): void;
+}
+
+/**
+ * @public
+ * Settings for an {@link AudioLevelsNode}
+ */
+export declare interface AudioLevelsSettings extends ProcessorNodeSettings<AudioLevelsNode> {
+    /**
+     * Called with the audio level data
+     * @param levels - The level data for the audio stream
+     * @eventProperty
+     */
+    onData: (levels: AudioLevels) => void;
+    intervalFrames?: number;
+}
+
+/**
+ * @public Mix N audio channels to M audio channels with a matrix of gains.
+ * Use {@link NorskTransform.audioMatrixMixer} to create one.
+ */
+export declare class AudioMatrixMixerNode extends AutoProcessorMediaNode<"audio"> {
+    /** @public */
+    updateConfig(settings: AudioMatrixMixerSettingsUpdate): void;
+    close(): void;
+}
+
+/** @public Config for the {@link AudioMatrixMixerNode} */
+export declare interface AudioMatrixMixerSettings extends ProcessorNodeSettings<AudioMatrixMixerNode> {
+    /** The NxM matrix of gains from N input channels to M output channels */
+    channelGains: readonly Gain[][];
+    /** The desired output channel layout, such as "5.1" */
+    outputChannelLayout: ChannelLayout;
+}
+
+/** @public Config update for the {@link AudioMatrixMixerNode}.
+ * Call {@link AudioMatrixMixerNode.updateConfig} for updating the config.
+ */
+export declare interface AudioMatrixMixerSettingsUpdate {
+    /** The NxM updated matrix of gains from N input channels to M output channels */
+    channelGains: readonly Gain[][];
+}
+
+/**
+ * @public
+ * {@link NorskTransform.audioMixer}
+ */
+export declare class AudioMixerNode<Pins extends string> extends ProcessorMediaNode<Pins> {
+    updateConfig(settings: AudioMixerSettingsUpdate<Pins>): void;
+    close(): void;
+}
+
+/** @public */
+export declare interface AudioMixerSettings<Pins extends string> extends ProcessorNodeSettings<AudioMixerNode<Pins>> {
+    /** The sources to mix */
+    sources: readonly AudioMixerSource<Pins>[];
+    /** The name of the output source */
+    outputSource: string;
+    /** The sample rate of the output */
+    sampleRate?: SampleRate;
+}
+
+/** @public */
+export declare interface AudioMixerSettingsUpdate<Pins extends string> {
+    sources: readonly AudioMixerSource<Pins>[];
+}
+
+/** @public */
+export declare interface AudioMixerSource<Pins> {
+    /** The name of the InputPin for this source */
+    pin: Pins;
+    /** A vector of gains for this source, one for each channel */
+    channelGains?: readonly Gain[];
+}
+
+/**
+ * @public
+ * {@link NorskInput.audioSignal}
+ */
+export declare class AudioSignalGeneratorNode extends SourceMediaNode {
+    close(): void;
+}
+
+/** @public */
+export declare interface AudioSignalGeneratorSettings extends SourceNodeSettings<AudioSignalGeneratorNode> {
+    sourceName: string;
+    channelLayout: ChannelLayout;
+    sampleRate: SampleRate;
+    /** The sample format to use.  Default: "fltp"  */
+    sampleFormat?: SampleFormat;
+    /** Waveform - create one with {@link mkSine} */
+    wave?: Wave;
+}
+
+/**
+ * @public
+ * {@link NorskTransform.audioSplitMultichannel}
+ */
+export declare class AudioSplitMultichannelNode extends AutoProcessorMediaNode<"audio"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface AudioSplitMultichannelSettings extends ProcessorNodeSettings<AudioSplitMultichannelNode> {
+    outputStreamKey: StreamKey;
+}
+
+/**
+ * @public
+ * Returns the stream keys for audio streams in a media context
+ * @param streams - The media context from which to return the stream keys
+ * @returns The audio stream keys in the media context
+ */
+export declare function audioStreamKeys(streams: readonly StreamMetadata[]): StreamKey[];
+
+/** @public */
+export declare interface AudioStreamMetadata {
+    codec: AudioCodec;
+    sampleRate: SampleRate;
+    channelLayout?: ChannelLayout;
+}
+
+/**
+ * @public
+ * Filters a context to only the audio streams within it
+ * @param streams - The media context from which to return the streams
+ * @returns The audio streams in the media context
+ */
+export declare function audioStreams(streams: readonly StreamMetadata[]): StreamMetadata[];
+
+/** @public */
+export declare const audioToPin: <Pins extends string>(pin: Pins) => (streams: StreamMetadata[]) => PinToKey<Pins>;
+
+declare interface AutoProcessorMediaNode<Pins extends string> extends SourceMediaNode, AutoSinkMediaNode<Pins> {
+}
+
+declare class AutoProcessorMediaNode<Pins extends string> {
+    constructor(client: MediaClient, subscribeFn: (subscription: Subscription) => void);
+}
+
+/** @public */
+export declare class AutoSinkMediaNode<Pins extends string> extends SinkMediaNode<Pins | "auto"> {
+    /** Subscribe to the given sources
+     * This version of subscribe simply requires a list of stream keys to be
+     * returned from each selector, and the server will automatically
+     * assign each stream to the appropriate pin on the sink node
+     * This is the appropriate method for most cases
+     */
+    subscribe(sources: ReceiveFromAddressAuto[], validation?: (context: Context) => boolean): void;
+}
+
+/** @public */
+export declare const avToPin: <Pins extends string>(pin: Pins) => (streams: StreamMetadata[]) => PinToKey<Pins>;
+
+/** @public */
+export declare interface AwsCredentials {
+    accessKey: string;
+    secretKey: string;
+    sessionToken: string;
+    region: string;
+}
+
+/** @public */
+export declare interface AwsS3PushDestinationSettings {
+    type: "s3";
+    host: string;
+    port: number;
+    pathPrefix: string;
+    sessionId?: string;
+    id: string;
+    awsRegion: string;
+    awsCredentials?: AwsCredentials;
+    retentionPeriodSeconds: number;
+}
+
+/**
+ * @public
+ * {@link NorskTransform.awsTranscribe}
+ */
+export declare class AwsTranscribeNode extends AutoProcessorMediaNode<"audio"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface AwsTranscribeSettings extends ProcessorNodeSettings<AwsTranscribeNode> {
+    awsRegion: string;
+    outputStreamId: number;
+    language: string;
+    sentenceBuildMode: SentenceBuildMode;
+    sentenceStabilizationMode: StabilizationMode;
+}
+
+/**
+ * @public
+ * There are three possible modes:
+ * - "abr": encode in average bitrate mode, specified in kilobits/sec (note, 1
+ *   kilobit is 1000 bits).  You can make use of the vbv settings to control
+ *   the bounds on how much the actual bitrate can fluctuate within the bounds
+ *   of the average
+ * - "cqp": encode in constant quantizer mode.  In general, crf will give better
+ *   results, although cqp can be faster to encode
+ * - "crf": encode in constant rate factor mode.  This will give a constant 'quality'
+ *   to the encode, but with a variable bitrate
+ */
+export declare interface BitrateMode {
+    value: number;
+    mode: "abr" | "cqp" | "crf";
+}
+
+/** @public */
+export declare type BrowserEvent = {
+    case: "onLoaded";
+    value: BrowserOnLoaded;
+} | {
+    case: "onLoadStart";
+    value: BrowserOnLoadStart;
+} | {
+    case: "onLoadEnd";
+    value: BrowserOnLoadEnd;
+} | {
+    case: "onLoadError";
+    value: BrowserOnLoadError;
+};
+
+/**
+ * @public
+ * {@link NorskInput.browser}
+ */
+export declare class BrowserInputNode extends SourceMediaNode {
+    updateConfig(settings: BrowserInputSettingsUpdate): void;
+    nudge(nudge: number): void;
+    close(): void;
+}
+
+/** @public */
+export declare interface BrowserInputSettings extends SourceNodeSettings<BrowserInputNode>, StreamStatsMixin {
+    url: string;
+    resolution: {
+        width: number;
+        height: number;
+    };
+    sourceName: string;
+    frameRate: FrameRate;
+    onBrowserEvent?: (event: BrowserEvent) => void;
+}
+
+/** @public */
+export declare interface BrowserInputSettingsUpdate {
+    url?: string;
+    resolution?: {
+        width: number;
+        height: number;
+    };
+}
+
+/** @public */
+export declare interface BrowserOnLoaded {
+    url: string;
+}
+
+/** @public */
+export declare interface BrowserOnLoadEnd {
+    url: string;
+    statusCode: number;
+}
+
+/** @public */
+export declare interface BrowserOnLoadError {
+    url: string;
+    errorText: string;
+    errorCode: number;
+}
+
+/** @public */
+export declare interface BrowserOnLoadStart {
+    url: string;
+}
+
+/** @public Channel layout for an audio stream */
+export declare type ChannelLayout = "mono" | "stereo" | "surround" | "4.0" | "5.0" | "5.1" | "7.1" | "5.1.4" | "7.1.4" | (ChannelName | ExplicitChannel)[];
+
+/** @public */
+export declare interface ChannelLevels {
+    rms?: Db;
+    peak?: Db;
+}
+
+/** @public */
+export declare type ChannelName = 
+/** Left front */
+"l"
+/** Right front */
+| "r"
+/** Centre front */
+| "c"
+/** Low frequency enhancement */
+| "lfe"
+/** Left surround */
+| "ls"
+/** Right surround */
+| "rs"
+/** Left front centre */
+| "lc"
+/** Right front centre */
+| "rc"
+/** Rear surround left */
+| "lsr"
+/** Rear Surround Right */
+| "rsr"
+/** Rear centre */
+| "cs"
+/** Left surround direct */
+| "lsd"
+/** Right surround direct */
+| "rsd"
+/** Left side surround */
+| "lss"
+/** Right side surround */
+| "rss"
+/** Left wide front */
+| "lw"
+/** Right wide front */
+| "rw"
+/** Left front vertical height */
+| "lv"
+/** Right front vertical height */
+| "rv"
+/** Centre front vertical height */
+| "cv"
+/** Left surround vertical height rear */
+| "lvr"
+/** Right surround vertical height rear */
+| "rvr"
+/** Centre vertical height rear */
+| "cvr"
+/** Left vertical height side surround */
+| "lvss"
+/** Right vertical height side surround */
+| "rvss"
+/** Top centre surround */
+| "ts"
+/** Low frequency enhancement 2 */
+| "lfe2"
+/** Left front vertical bottom */
+| "lb"
+/** Right front vertical bottom */
+| "rb"
+/** Centre front vertical bottom */
+| "cb"
+/** Left vertical height surround */
+| "lvs"
+/** Right vertical height surround */
+| "rvs"
+/** Low frequency enhancement 3 */
+| "lfe3"
+/** Left edge of screen */
+| "leos"
+/** Right edge of screen */
+| "reos"
+/** Halfway between centre of screen and left edge of screen */
+| "hwbcal"
+/** Halfway between centre of screen and right edge of screen */
+| "hwbcar"
+/** Left back surround */
+| "lbs"
+/** Right back surround  */
+| "rbs"
+/**  Unknown */
+| "unknown";
+
+/**
+ * @public
+ * {@link NorskTransform.chaosMonkey}
+ */
+export declare class ChaosMonkeyNode extends AutoProcessorMediaNode<"audio" | "video" | "subtitle"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface ChaosMonkeySettings extends ProcessorNodeSettings<ChaosMonkeyNode> {
+    frameDrop?: DropRandom | DropEvery;
+}
+
+/** @public */
+export declare type CMAFDestinationSettings = HlsPushDestinationSettings | AwsS3PushDestinationSettings | LocalPullDestinationSettings;
+
+declare class CommonHlsNode<ClientMessage, Pins extends string, T extends MediaNodeState> extends AutoSinkMediaNode<Pins> {
+    constructor(client: MediaClient, settings: NodeSettings<T> & StreamStatsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => void, subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => void);
+    close(): void;
+}
+
+/** @public */
+export declare type ComposeMissingStreamBehaviour = 
+/**
+* Produce frames on output by dropping the part(s) of the composition which
+* cannot be fulfilled.
+*/
+"drop_part"
+/**
+* Wait for all streams to be present before producing (further) output
+*/
+| "wait_for_all";
+
+/** @public */
+export declare interface ComposePart<Pins> {
+    pin: Pins;
+    sourceRect: OffsetRect;
+    destRect: OffsetRect;
+    zIndex: number;
+    opacity: number;
+    id?: string;
+    transition?: PartTransition;
+    referenceResolution?: Resolution;
+}
+
+/**
+ * @public
+ * {@link NorskTransform.composeOverlay}
+ */
+export declare class ComposeVideoNode<Pins extends string> extends ProcessorMediaNode<Pins> {
+    updateConfig(settings: ComposeVideoSettingsUpdate<Pins>): void;
+    close(): void;
+}
+
+/** @public */
+export declare interface ComposeVideoSettings<Pins extends string> extends ProcessorNodeSettings<ComposeVideoNode<Pins>> {
+    referenceStream: Pins;
+    parts: readonly ComposePart<Pins>[];
+    referenceResolution?: Resolution;
+    outputResolution: Resolution;
+    outputPixelFormat?: PixelFormat;
+    missingStreamBehaviour?: ComposeMissingStreamBehaviour;
+    onTransitionComplete?: () => void;
+}
+
+/** @public */
+export declare interface ComposeVideoSettingsUpdate<Pins extends string> {
+    parts: readonly ComposePart<Pins>[];
+}
+
+/** @public */
+export declare interface Core {
+    logicalCpuIds: LogicalCpuId[];
+}
+
+/** @public */
+export declare interface CpuTopology {
+    numaNodes: NumaNode[];
+}
+
+/** @public A decibel (dB). A null value represents -inf. */
+export declare type Db = number | null;
+
+/** @public */
+export declare interface DeckLinkCard {
+    index: number;
+    displayName: string;
+    inputConnections: DeckLinkVideoConnection[];
+    outputConnections: DeckLinkVideoConnection[];
+    ioSupport: DeckLinkVideoIOSupport[];
+}
+
+/** @public */
+export declare interface DeckLinkDisplayMode {
+    id: DeckLinkDisplayModeId;
+    name: string;
+    width: number;
+    height: number;
+    frameRate: FrameRate;
+}
+
+/** @public */
+export declare type DeckLinkDisplayModeId = "auto" | "sd_ntsc" | "sd_nt23" | "sd_pal" | "sd_ntsp" | "sd_palp" | "hd1080_23ps" | "hd1080_24ps" | "hd1080_p25" | "hd1080_p29" | "hd1080_p30" | "hd1080_p47" | "hd1080_p48" | "hd1080_i50" | "hd1080_i59" | "hd1080_i60" | "hd1080_p95" | "hd1080_p96" | "hd1080_p10" | "hd1080_p11" | "hd1080_p12" | "hd1080_p50" | "hd1080_p59" | "hd1080_p60" | "hd720_p50" | "hd720_p59" | "hd720_p60" | "two_k_23" | "two_k_24" | "two_k_25" | "two_k_dci_23" | "two_k_dci_24" | "two_k_dci_25" | "two_k_dci_29" | "two_k_dci_30" | "two_k_dci_47" | "two_k_dci_48" | "two_k_dci_50" | "two_k_dci_59" | "two_k_dci_60" | "two_k_dci_95" | "two_k_dci_96" | "two_k_dci_10" | "two_k_dci_11" | "two_k_dci_12" | "four_k_23" | "four_k_24" | "four_k_25" | "four_k_29" | "four_k_30" | "four_k_47" | "four_k_48" | "four_k_50" | "four_k_59" | "four_k_60" | "four_k_95" | "four_k_96" | "four_k_10" | "four_k_11" | "four_k_12" | "four_k_dci_23" | "four_k_dci_24" | "four_k_dci_25" | "four_k_dci_29" | "four_k_dci_30" | "four_k_dci_47" | "four_k_dci_48" | "four_k_dci_50" | "four_k_dci_59" | "four_k_dci_60" | "four_k_dci_95" | "four_k_dci_96" | "four_k_dci_10" | "four_k_dci_11" | "four_k_dci_12" | "eight_k_23" | "eight_k_24" | "eight_k_25" | "eight_k_29" | "eight_k_30" | "eight_k_47" | "eight_k_48" | "eight_k_50" | "eight_k_59" | "eight_k_60" | "eight_k_dci_23" | "eight_k_dci_24" | "eight_k_dci_25" | "eight_k_dci_29" | "eight_k_dci_30" | "eight_k_dci_47" | "eight_k_dci_48" | "eight_k_dci_50" | "eight_k_dci_59" | "eight_k_dci_60" | "pc_vga6" | "pc_svg6" | "pc_wxg5" | "pc_wxg6" | "pc_sxg5" | "pc_sxg6" | "pc_uxg5" | "pc_uxg6" | "pc_wux5" | "pc_wux6" | "pc_1945" | "pc_1946" | "pc_wqh5" | "pc_wqh6" | "pc_wqx5" | "pc_wqx6" | "special_iunk";
+
+/**
+ * @public
+ * SDI capture through a DeckLink card. Create an ingest with {@link NorskInput.deckLink}.
+ */
+export declare class DeckLinkInputNode extends SourceMediaNode {
+    nudge(nudge: number): void;
+    close(): void;
+}
+
+/**
+ * @public
+ * Settings to control SDI capture through a DeckLink card
+ */
+export declare interface DeckLinkInputSettings extends InputSettings<DeckLinkInputNode>, StreamStatsMixin {
+    /** Which card to use */
+    cardIndex: number;
+    /** The audio channel layout for the input */
+    channelLayout: ChannelLayout;
+    /**  SDI or HDMI capture */
+    videoConnection: DeckLinkVideoConnection;
+    /** Typically left undefined, but can be used to force capture for a specific {@link DeckLinkDisplayModeId}.  If
+     * the source is not currently in this mode, then no capture will occur. */
+    displayModeId?: DeckLinkDisplayModeId;
+    pixelFormat?: DeckLinkPixelFormat;
+}
+
+/** @public */
+export declare type DeckLinkPixelFormat = "uyvy" | "argb";
+
+/** @public */
+export declare type DeckLinkVideoConnection = "sdi" | "hdmi" | "optical_sdi" | "component" | "composite" | "svideo";
+
+/**  @public */
+export declare type DeckLinkVideoIOSupport = "capture" | "playback";
+
+/** @public */
+export declare interface DropEvery {
+    kind: "every";
+    every: number;
+}
+
+/** @public */
+export declare interface DropRandom {
+    kind: "random";
+    percentage: number;
+}
+
+/** @public */
+export declare interface FrameRate {
+    frames: number;
+    seconds: number;
+}
+
+/**
+ * @public
+ * A relative change in decibels, expressing a power ratio.
+ *
+ * A value of 0dB means no change, positive values mean an increase in power, and negative values mean a decrease in power.
+ */
+export declare type Gain = Db;
+
+/** @public */
+export declare function getAmountOfChannels(layout: ChannelLayout): number;
+
+/**
+ * @public
+ * {@link NorskControl.hardSwitcher}
+ */
+export declare class HardSwitcherNode<Pins extends string> extends ProcessorMediaNode<Pins> {
+    switchSource(newSource: Pins): void;
+    close(): void;
+}
+
+/** @public */
+export declare interface HardSwitcherSettings<Pins extends string> extends ProcessorNodeSettings<HardSwitcherNode<Pins>> {
+    activeSource: Pins;
+    outputSource: string;
+}
+
+/**
+ * @public
+ *
+ */
+/**
+ * @public
+ */
+export declare interface HardwareInfo {
+    cpuTopology: CpuTopology;
+    systemMemory: number;
+    deckLinkCards: DeckLinkCard[];
+}
+
+/**
+ * @public
+ * {@link NorskOutput.hlsAudio}
+ */
+export declare class HlsAudioOutputNode extends HlsNodeWithPlaylist<HlsAudioMessage, "audio", HlsAudioOutputNode> {
+    updateCredentials(settings: UpdateCredentials): void;
+}
+
+/** @public */
+export declare interface HlsAudioOutputSettings extends NodeSettings<HlsAudioOutputNode> {
+    segmentDurationSeconds: number;
+    partDurationSeconds: number;
+    delayOutputMs?: number;
+    encryption?: {
+        encryptionKey: string;
+        encryptionKeyId: string;
+    };
+    destinations: CMAFDestinationSettings[];
+}
+
+/**
+ * @public
+ * {@link NorskOutput.hlsMaster}
+ */
+export declare class HlsMasterOutputNode extends CommonHlsNode<HlsMasterMessage, "video" | "audio" | "subtitle", HlsMasterOutputNode> {
+    /** @public The URL of the master playlist */
+    playlistUrl: string;
+    updateCredentials(settings: UpdateCredentials): void;
+}
+
+/** @public */
+export declare interface HlsMasterOutputSettings extends NodeSettings<HlsMasterOutputNode> {
+    playlistName: string;
+    pathPrefix?: string;
+    destinations: CMAFDestinationSettings[];
+}
+
+/**
+ * @public
+ * {@link NorskOutput.hlsMasterPush}
+ */
+export declare class HlsMasterPushOutputNode extends CommonHlsNode<HlsMasterPushMessage, "video" | "audio" | "subtitle", HlsMasterPushOutputNode> {
+}
+
+/** @public */
+export declare interface HlsMasterPushOutputSettings extends NodeSettings<HlsMasterPushOutputNode> {
+    playlistName: string;
+    destination: CMAFDestinationSettings;
+}
+
+declare class HlsNodeWithPlaylist<ClientMessage, Pins extends string, T extends MediaNodeState> extends CommonHlsNode<ClientMessage, Pins, T> {
+    constructor(client: MediaClient, settings: NodeSettings<T> & StreamStatsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => void);
+    /** @public
+     * Returns the URL to the HLS playlist entry.  Note this can only be evaluated once the stream is active as it
+     * varies with the stream subscribed to.  Useful during development, but you probably want to
+     * use {@link NorskOutput.hlsMaster} for production.
+     */
+    url(): Promise<string>;
+}
+
+/** @public */
+export declare interface HlsPushDestinationSettings {
+    type: "generic";
+    host: string;
+    port: number;
+    pathPrefix: string;
+    sessionId?: string;
+    id: string;
+    retentionPeriodSeconds: number;
+}
+
+/**
+ * @public
+ * {@link NorskOutput.hlsTsAudio}
+ */
+export declare class HlsTsAudioOutputNode extends CommonHlsNode<HlsTsAudioMessage, "audio", HlsTsAudioOutputNode> {
+}
+
+/** @public */
+export declare interface HlsTsAudioOutputSettings extends NodeSettings<HlsTsAudioOutputNode> {
+    segmentDurationSeconds: number;
+    delayOutputMs?: number;
+}
+
+/**
+ * @public
+ * {@link NorskOutput.hlsTsAudioPush}
+ */
+export declare class HlsTsAudioPushOutputNode extends CommonHlsNode<HlsTsAudioPushMessage, "audio", HlsTsAudioOutputNode> {
+}
+
+/** @public */
+export declare interface HlsTsAudioPushOutputSettings extends NodeSettings<HlsTsAudioPushOutputNode> {
+    segmentDurationSeconds: number;
+    delayOutputMs?: number;
+    destination: CMAFDestinationSettings;
+}
+
+/**
+ * @public
+ * {@link NorskOutput.hlsTsCombinedPush}
+ */
+export declare class HlsTsCombinedPushOutputNode extends CommonHlsNode<HlsTsCombinedPushMessage, "audio" | "video", HlsTsCombinedPushOutputNode> {
+}
+
+/** @public */
+export declare interface HlsTsCombinedPushOutputSettings extends NodeSettings<HlsTsCombinedPushOutputNode> {
+    segmentDurationSeconds: number;
+    delayOutputMs?: number;
+    destination: CMAFDestinationSettings;
+    playlistName: string;
+}
+
+/**
+ * @public
+ * {@link NorskOutput.hlsTsVideo}
+ */
+export declare class HlsTsVideoOutputNode extends CommonHlsNode<HlsTsVideoMessage, "video", HlsTsVideoOutputNode> {
+}
+
+/** @public */
+export declare interface HlsTsVideoOutputSettings extends NodeSettings<HlsTsVideoOutputNode> {
+    segmentDurationSeconds: number;
+    delayOutputMs?: number;
+}
+
+/**
+ * @public
+ * {@link NorskOutput.hlsTsVideoPush}
+ */
+export declare class HlsTsVideoPushOutputNode extends CommonHlsNode<HlsTsVideoPushMessage, "video", HlsTsVideoOutputNode> {
+}
+
+/** @public */
+export declare interface HlsTsVideoPushOutputSettings extends NodeSettings<HlsTsVideoPushOutputNode> {
+    segmentDurationSeconds: number;
+    delayOutputMs?: number;
+    destination: CMAFDestinationSettings;
+}
+
+/**
+ * @public
+ * {@link NorskOutput.hlsVideo}
+ */
+export declare class HlsVideoOutputNode extends HlsNodeWithPlaylist<HlsVideoMessage, "video", HlsVideoOutputNode> {
+    updateCredentials(settings: UpdateCredentials): void;
+}
+
+/** @public */
+export declare interface HlsVideoOutputSettings extends NodeSettings<HlsVideoOutputNode> {
+    segmentDurationSeconds: number;
+    partDurationSeconds: number;
+    delayOutputMs?: number;
+    sessionId?: string;
+    id: string;
+    encryption?: {
+        encryptionKey: string;
+        encryptionKeyId: string;
+    };
+    destinations: CMAFDestinationSettings[];
+}
+
+/**
+ * @public
+ * {@link NorskOutput.hlsWebVtt}
+ */
+export declare class HlsWebVttOutputNode extends HlsNodeWithPlaylist<HlsWebVttMessage, "subtitle", HlsWebVttOutputNode> {
+}
+
+/** @public */
+export declare interface HlsWebVttOutputSettings extends NodeSettings<HlsWebVttOutputNode> {
+    segmentDurationSeconds: number;
+    sessionId?: string;
+    delayOutputMs?: number;
+}
+
+/**
+ * @public
+ * {@link NorskOutput.hlsWebVttPush}
+ */
+export declare class HlsWebVttPushOutputNode extends CommonHlsNode<HlsWebVttPushMessage, "subtitle", HlsWebVttPushOutputNode> {
+}
+
+export declare interface HlsWebVttPushOutputSettings extends NodeSettings<HlsWebVttPushOutputNode> {
+    segmentDurationSeconds: number;
+    delayOutputMs?: number;
+    destination: CMAFDestinationSettings;
+    retentionPeriodSeconds: number;
+    hlsCacheDirectory: string;
+    maximumPlaylistSegments: number;
+}
+
+/**
+ * @public
+ * {@link NorskInput.imageFile}
+ */
+export declare class ImageFileInputNode extends SourceMediaNode {
+    close(): void;
+}
+
+/** @public */
+export declare interface ImageFileInputSettings extends SourceNodeSettings<ImageFileInputNode>, StreamStatsMixin {
+    sourceName: string;
+    fileName: string;
+    /** The file format for the image. Will be inferred from the file name if not specified. */
+    imageFormat?: ImageFormat;
+}
+
+/** @public */
+export declare type ImageFormat = "png" | "jpeg" | "gif" | "webp" | "pnm" | "tiff" | "tga" | "dds" | "bmp" | "ico" | "hdr" | "openexr" | "farbfeld" | "avif";
+
+/** @public */
+export declare interface InputSettings<T extends MediaNodeState> extends SourceNodeSettings<T> {
+    sourceName: string;
+}
+
+/** @public A time interval measured as ticks / (ticks per second) */
+export declare interface Interval {
+    n: number;
+    d: number;
+}
+
+/** @public */
+export declare interface LocalFileInputSettings extends InputSettings<SourceMediaNode> {
+    fileName: string;
+    onEof?: () => void;
+}
+
+/** @public */
+export declare interface LocalPullDestinationSettings {
+    type: "local";
+    sessionId?: string;
+    retentionPeriodSeconds: number;
+}
+
+/**
+ * @public
+ * {@link NorskDuplex.localWebRTC}
+ */
+export declare class LocalWebRTCNode extends AutoProcessorMediaNode<"audio" | "video"> {
+    /** @public The URL of the local player */
+    playerUrl: string;
+    close(): void;
+}
+
+/** @public */
+export declare interface LocalWebRTCSettings extends ProcessorNodeSettings<LocalWebRTCNode>, StreamStatsMixin {
+}
+
+/** @public */
+export declare type Log = {
+    level: "emergency" | "alert" | "critical" | "error" | "warning" | "notice" | "info" | "debug";
+    timestamp: Date;
+    message: string;
+};
+
+/** @public */
+export declare type LogicalCpuId = number;
+
+/** @public */
+export declare type MediaNodeId = string;
+
+/** @public */
+export declare class MediaNodeState {
+    id: MediaNodeId | undefined;
+    constructor(client: MediaClient);
+    close(): void;
+}
+
+/**
+ * @public
+ * {@link NorskTransform.metadataOverride}
+ */
+export declare class MetadataOverrideNode extends AutoProcessorMediaNode<"audio" | "video" | "subtitle"> {
+    updateConfig(settings: MetadataOverrideSettingsUpdate): void;
+    close(): void;
+}
+
+/** @public */
+export declare interface MetadataOverrideSettings extends ProcessorNodeSettings<MetadataOverrideNode>, MetadataOverrideSettingsUpdate {
+}
+
+/** @public */
+export declare interface MetadataOverrideSettingsUpdate {
+    video?: {
+        /** Override the bitrate metadata of a compressed video stream, or `0` to clear */
+        bitrate?: number;
+    };
+    audio?: {
+        /** Override the bitrate metadata of a compressed audio stream, or `0` to clear */
+        bitrate?: number;
+        /** Override the language metadata of an audio stream, or `""` to clear */
+        language?: string;
+    };
+    subtitles?: {
+        /** Override the language metadata of a subtitles stream, or `""` to clear */
+        language?: string;
+    };
+}
+
+/**
+ * @public
+ * Generate encryption parameters from from an encryption KeyID and Key,
+ * in the form KEYID:KEY, both 16byte hexadecimal
+ */
+export declare function mkEncryption(encryption: string | undefined): {
+    encryptionKey: string;
+    encryptionKeyId: string;
+} | undefined;
+
+/** @public */
+export declare function mkSine(freq: number): Wave;
+
+/** @public */
+export declare interface Mp4FileInfo {
+    durationMs?: number;
+    byteLength?: number;
+}
+
+/**
+ * @public
+ * {@link NorskInput.localMp4File}
+ */
+export declare class Mp4FileInputNode extends SourceMediaNode {
+    nudge(nudge: number): void;
+    close(): void;
+}
+
+/**
+ * @public
+ * Settings to control reading from an MP4 file
+ */
+export declare interface Mp4FileInputSettings extends SourceNodeSettings<Mp4FileInputNode>, StreamStatsMixin {
+    sourceName: string;
+    /** Path to the MP4 file to read */
+    fileName: string;
+    /** Callback to be notified when the file ends */
+    onEof?: () => void;
+    onInfo?: (info: Mp4FileInfo) => void;
+}
+
+/**
+ * @public
+ * {@link NorskOutput.localMp4File}
+ */
+export declare class Mp4FileOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+    close(): void;
+    writeFile(nonfragmentedFileName: string): void;
+}
+
+/**
+ * @public
+ * Settings to control MP4 file output
+ */
+export declare interface Mp4FileOutputSettings extends NodeSettings<Mp4FileOutputNode>, StreamStatsMixin {
+    /**
+     * Required: stream fragmented MP4 to this file.
+     */
+    fragmentedFileName: string;
+    /**
+     * Write non-fragmented MP4 to this file on close, creates a `.tmp` file to
+     * store the frame data.
+     */
+    nonfragmentedFileName?: string;
+    /**
+     * Common encryption (CENC) key and key ID to use, both 16-bytes encoded in
+     * hexadecimal (32 chars).
+     */
+    encryption?: {
+        encryptionKey: string;
+        encryptionKeyId: string;
+    };
+}
+
+/** @public */
+export declare interface MultiStreamStats {
+    allStreams: SingleStreamStats[];
+    sampleSizeSeconds: number;
+    total: StreamStats;
+    audio: StreamStats;
+    video: StreamStats;
+}
+
+/** @public */
+export declare interface NetintH264 {
+    type: "ni-h264";
+    extraOpts?: string;
+    enableAud?: boolean;
+    gpuIndex?: number;
+    bitrate?: number;
+    flushGop?: boolean;
+    enableVfr?: boolean;
+    crf?: number;
+    cbr?: boolean;
+    gopPresetIndex?: number;
+    intraPeriod?: number;
+    rcEnable?: boolean;
+    intraQp?: number;
+    rcInitDelay?: number;
+    profile?: NetintH264Profile;
+    level?: NetintH264Level;
+}
+
+/** @public */
+export declare type NetintH264Level = 1 | 2 | 2.1 | 3 | 3.1 | 4 | 4.1 | 5 | 5.1 | 5.2 | 6 | 6.1 | 6.2;
+
+/** @public */
+export declare type NetintH264Profile = "baseline" | "main" | "extended" | "high" | "high10";
+
+/** @public */
+export declare interface NetintHevc {
+    type: "ni-hevc";
+    extraOpts?: string;
+    enableAud?: boolean;
+    gpuIndex?: number;
+    bitrate?: number;
+    flushGop?: boolean;
+    enableVfr?: boolean;
+    crf?: number;
+    cbr?: boolean;
+    gopPresetIndex?: number;
+    intraPeriod?: number;
+    rcEnable?: boolean;
+    intraQp?: number;
+    rcInitDelay?: number;
+    profile?: NetintHevcProfile;
+    level?: NetintHevcLevel;
+    tier?: NetintHevcTier;
+    lossless?: boolean;
+    hrdEnable?: boolean;
+    dolbyVisionProfile?: number;
+}
+
+/** @public */
+export declare type NetintHevcLevel = 1 | 2 | 2.1 | 3 | 3.1 | 4 | 4.1 | 5 | 5.1 | 5.2 | 6 | 6.1 | 6.2;
+
+/** @public */
+export declare type NetintHevcProfile = "main" | "main10";
+
+/** @public */
+export declare type NetintHevcTier = "main" | "high";
+
+/** @public */
+export declare function newSilentMatrix(rows: number, cols: number): Gain[][];
+
+/**
+ * @public
+ * Settings common to all media nodes
+ */
+export declare interface NodeSettings<T extends MediaNodeState> {
+    /**
+     * Media Node identifier. If one is not specified, a random identifier will be generated.
+     */
+    id?: string;
+    /**
+     * Called when the Norsk session ends
+     */
+    onEnd?: () => void;
+    /**
+     * Called with any errors from the Node
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Called when the Node closes
+     */
+    onClose?: () => void;
+    /**
+     * Callback to synchronously perform an action when node creation is complete
+     * (e.g. subscribe a downstream node before the first context/frame might arrive)
+     */
+    onCreate?: (node: T) => void;
+}
+
+/**
+ * @public
+ * The entrypoint for all Norsk Media applications
+ *
+ * @example
+ * ```ts
+ * const norsk = new Norsk();
+ * ```
+ */
+export declare class Norsk {
+    /**
+     * Implements the {@link NorskInput} interface
+     */
+    input: NorskInput;
+    /**
+     * Implements the {@link NorskOutput} interface
+     */
+    output: NorskOutput;
+    /**
+     * Implements the {@link NorskDuplex} interface
+     */
+    duplex: NorskDuplex;
+    /**
+     * Implements the {@link NorskProcessor} interface
+     */
+    processor: NorskProcessor;
+    /**
+     * Implements the {@link NorskSystem} interface
+     */
+    system: NorskSystem;
+    /**
+     * Norsk Runtime version informatio
+     */
+    version: Version;
+    close(): void;
+    /** @public */
+    static connect(settings?: NorskSettings): Promise<Norsk>;
+}
+
+/**
+ * @public
+ * Methods that allow you to control and monitor media streams
+ */
+export declare interface NorskControl {
+    /**
+     * Switch between multiple input sources via a hard cut. May be used to switch between
+     * sources of possibly different configurations or without decoding.
+     * @param settings - Options for the switcher
+     */
+    hardSwitcher<Pins extends string>(settings: HardSwitcherSettings<Pins>): Promise<HardSwitcherNode<Pins>>;
+    /**
+     * Switch between multiple input sources without interruption, via a transition.
+     * @param settings - Options for the switcher
+     */
+    smoothSwitcher<Pins extends string>(settings: SmoothSwitcherSettings<Pins>): Promise<SmoothSwitcherNode<Pins>>;
+    /**
+     * Record statistical information about media streams, including bitrate,
+     * frame rate, and number of keyframes, measured over some configurable
+     * sampling windows.
+     * @param settings - Callback and sampling intervals
+     */
+    streamStats(settings: StreamStatsSettings): Promise<StreamStatsNode>;
+    /**
+     * Monitor the volume of an audio stream
+     * @param settings - Callback and options for the level data
+     */
+    audioLevels(settings: AudioLevelsSettings): Promise<AudioLevelsNode>;
+}
+
+/**
+ * @public
+ * Methods that allow you to both ingest and egest media from your application
+ * at the same time
+ */
+export declare interface NorskDuplex {
+    /**
+     * Playback audio/video via webrtc to a browser, and accept audio/video input from a browser.
+     * The browser client must conform to a custom protocol as implemented in the hosted test page.
+     * For general WebRTC ingest prefer the WHIP input node, and for egest to a downstream media server
+     * use the WHIP output node.
+     * @param settings - Options for the webrtc node
+     */
+    localWebRTC(settings: LocalWebRTCSettings): Promise<LocalWebRTCNode>;
+}
+
+/**
+ * @public
+ * Methods that allow you to ingest media into your application
+ */
+export declare interface NorskInput {
+    /** Create an RTMP Server to receive RTMP streams into your application
+     * @param settings - Configuration for the RTMP server
+     */
+    rtmpServer(settings: RtmpServerInputSettings): Promise<RtmpServerInputNode>;
+    localTsFile(settings: LocalFileInputSettings): Promise<TsFileInputNode>;
+    /**
+     * Stream from a SRT source
+     * @param settings - Configuration for the SRT input
+     */
+    srt(settings: SrtInputSettings): Promise<SrtInputNode>;
+    whip(settings: WhipInputSettings): Promise<WhipInputNode>;
+    udpTs(settings: RemoteInputSettings<UdpTsInputNode>): Promise<UdpTsInputNode>;
+    localWebVttFile(settings: LocalFileInputSettings): Promise<WebVttFileInputNode>;
+    /**
+     * Read an image from a file. Various image formats are supported, see the
+     * documentation for {@link ImageFileInputSettings} for more details.
+     * @param settings - Configuration for the file input
+     */
+    imageFile(settings: ImageFileInputSettings): Promise<ImageFileInputNode>;
+    /**
+     * Read a MP4 (fragmented or not) from a file with realtime playback.
+     * This will not play frames that are written to the file after the node
+     * starts.
+     * @param settings - Configuration for the file input
+     */
+    localMp4File(settings: Mp4FileInputSettings): Promise<Mp4FileInputNode>;
+    /**
+     * Stream from a remote RTP source
+     * @param settings - Configuration for the RTP input
+     */
+    rtp(settings: RtpInputSettings): Promise<RtpInputNode>;
+    /**
+     * Generate a test audio signal with a configurable waveform.
+     * @param settings - Configuration for the audio signal
+     */
+    audioSignal(settings: AudioSignalGeneratorSettings): Promise<AudioSignalGeneratorNode>;
+    /**
+     * Video source from rendering an HTML page
+     * @param settings - Settings for the web page
+     */
+    browser(settings: BrowserInputSettings): Promise<BrowserInputNode>;
+    /**
+     * SDI/HDMI Input using a BlackMagic DeckLink card.
+     * The available cards on the machine can be enumerated using the {@link NorskSystem.hardwareInfo} API.
+     *
+     * Multiple cards and both SDI and HDMI inputs are supported, with all DeckLink-supported
+     * input resolutions and framerates are supported.  The capture format is currently 8-bit only,
+     * but 10-bit captures will be supported soon.  All supported audio channels can be captured.
+     * At present, additional data such as closed-captions and HDR metadata is not captured.
+     * @param settings - Settings for the SDI capture
+     */
+    deckLink(settings: DeckLinkInputSettings): Promise<DeckLinkInputNode>;
+}
+
+/**
+ * @public
+ *  * Methods that allow you to egest media from your application
+ */
+export declare interface NorskOutput {
+    hlsVideo(settings: HlsVideoOutputSettings): Promise<HlsVideoOutputNode>;
+    hlsAudio(settings: HlsAudioOutputSettings): Promise<HlsAudioOutputNode>;
+    hlsWebVtt(settings: HlsWebVttOutputSettings): Promise<HlsWebVttOutputNode>;
+    hlsWebVttPush(settings: HlsWebVttPushOutputSettings): Promise<HlsWebVttPushOutputNode>;
+    hlsTsVideo(settings: HlsTsVideoOutputSettings): Promise<HlsTsVideoOutputNode>;
+    tsUdp(settings: TsUdpOutputSettings): Promise<TsUdpOutputNode>;
+    srt(settings: SrtOutputSettings): Promise<SrtOutputNode>;
+    hlsTsAudio(settings: HlsTsAudioOutputSettings): Promise<HlsTsAudioOutputNode>;
+    hlsTsVideoPush(settings: HlsTsVideoPushOutputSettings): Promise<HlsTsVideoPushOutputNode>;
+    hlsTsAudioPush(settings: HlsTsAudioPushOutputSettings): Promise<HlsTsAudioPushOutputNode>;
+    hlsTsCombinedPush(settings: HlsTsCombinedPushOutputSettings): Promise<HlsTsCombinedPushOutputNode>;
+    hlsMaster(settings: HlsMasterOutputSettings): Promise<HlsMasterOutputNode>;
+    hlsMasterPush(settings: HlsMasterPushOutputSettings): Promise<HlsMasterPushOutputNode>;
+    webRTCWhip(settings: WebRTCWhipOutputSettings): Promise<WebRTCWhipOutputNode>;
+    rtmp(settings: RtmpOutputSettings): Promise<RtmpOutputNode>;
+    localTsFile(settings: TsFileOutputSettings): Promise<TsFileOutputNode>;
+    /**
+     * Output MP4 files to disk, both fragmented and non-fragmented.
+     *
+     * The fragmented output is required.
+     *
+     * The optional non-fragmented filename will be written when calling
+     * {@link Mp4FileOutputNode.close} and will be fully written by the time
+     * {@link NodeSettings.onEnd} is called. This sets up a temp file to
+     * store the frame data by appending the extension `.tmp`.
+     *
+     * A non-fragmented MP4 file can be written on request with
+     * {@link Mp4FileOutputNode.writeFile}, which uses the frame data store if
+     * {@link Mp4FileOutputSettings.nonfragmentedFileName} was given or reads
+     * back the fragmented mp4 if there is no non-fragmented file.
+     */
+    localMp4File(settings: Mp4FileOutputSettings): Promise<Mp4FileOutputNode>;
+}
+
+/** @public */
+export declare class NorskProcessor {
+    /**
+     * Implements the {@link NorskControl} interface
+     */
+    control: NorskControl;
+    /**
+     * Implements the {@link NorskTransform} interface
+     */
+    transform: NorskTransform;
+    close(): Promise<void>;
+    constructor(client: MediaClient);
+}
+
+/**
+ * @public
+ * Top level Norsk configuration
+ */
+export declare interface NorskSettings {
+    /**
+     * Callback URL to listen on for gRPC session with Norsk Media
+     * Defaults to $NORSK_HOST:$NORSK_PORT if the environment variables are set
+     * where NORSK_HOST defaults to "127.0.0.1" and NORSK_PORT to "6790"
+     * (so "127.0.0.1:6790" if neither variable is set)
+     */
+    url?: string;
+    onAttemptingToConnect?: () => void;
+    onConnecting?: () => void;
+    onReady?: () => void;
+    onFailedToConnect?: () => void;
+    /** Code to execute if the Norsk node is shutdown - by default if logs and exits the client application */
+    onShutdown?: () => void;
+    onCurrentLoad?: (load: CurrentLoad) => void;
+    onHello?: (version: Version) => void;
+    onLogEvent?: (log: Log) => void;
+    /**
+     * Manually handle license events, such as missing/invalid licenses and
+     * sandbox timeout. (Logs messages to console by default.)
+     */
+    onLicenseEvent?: (message: string) => void;
+}
+
+/**
+ * @public
+ * Methods that allow you query the features of the system that Norsk is running in
+ */
+export declare interface NorskSystem {
+    hardwareInfo(): Promise<HardwareInfo>;
+}
+
+/**
+ * @public
+ * Methods that allow you to manipulate your media streams
+ */
+export declare interface NorskTransform {
+    /**
+     * Encode a video stream to one or more renditions
+     * @param settings - Encode ladder settings
+     */
+    videoEncodeLadder(settings: VideoEncodeLadderSettings): Promise<VideoEncodeLadderNode>;
+    /**
+     * Transform a video stream (rescale, etc)
+     * @param settings - Transform settings
+     */
+    videoTransform(settings: VideoTransformSettings): Promise<VideoTransformNode>;
+    /**
+     * Interferes with a stream by dropping frames
+     * @param settings - Chaos monkey settings
+     */
+    chaosMonkey(settings: ChaosMonkeySettings): Promise<ChaosMonkeyNode>;
+    /**
+     * Compose multiple video streams together into a single output
+     * @param settings - Composition setting
+     */
+    composeOverlay<Pins extends string>(settings: ComposeVideoSettings<Pins>): Promise<ComposeVideoNode<Pins>>;
+    awsTranscribe(settings: AwsTranscribeSettings): Promise<AwsTranscribeNode>;
+    /**
+     * Mix multiple audio streams together into a single output,
+     * with optional gain control on each input.
+     * @param settings - Settings for the mixer, including the gain vectors
+     */
+    audioMixer<Pins extends string>(settings: AudioMixerSettings<Pins>): Promise<AudioMixerNode<Pins>>;
+    /**
+     * Given an audio stream of N channels, mix it down to M channels through a matrix of NxM gains.
+     * @param settings - Settings for the mixer, including the gain matrix
+     */
+    audioMatrixMixer(settings: AudioMatrixMixerSettings): Promise<AudioMatrixMixerNode>;
+    /**
+     * Apply gain to an audio stream
+     * @param settings - Settings for the gain node
+     */
+    audioGain(settings: AudioGainSettings): Promise<AudioGainNode>;
+    audioBuildMultichannel(settings: AudioBuildMultichannelSettings): Promise<AudioBuildMultichannelNode>;
+    audioSplitMultichannel(settings: AudioSplitMultichannelSettings): Promise<AudioSplitMultichannelNode>;
+    audioEncoder(settings: AudioEncoderSettings): Promise<AudioEncoderNode>;
+    timestampNudge(settings: TimestampNudgerSettings): Promise<TimestampNudgerNode>;
+    streamKeyOverride(settings: StreamKeyOverrideSettings): Promise<StreamKeyOverrideNode>;
+    metadataOverride(settings: MetadataOverrideSettings): Promise<MetadataOverrideNode>;
+    sync(settings: SyncSettings): Promise<SyncNode>;
+}
+
+/** @public */
+export declare interface NumaNode {
+    processors: Processor[];
+}
+
+/** @public */
+export declare interface NvidiaH264 {
+    type: "nv-h264";
+    preset?: NvidiaPreset;
+    idrPeriod?: number;
+    gopInterval?: number;
+    frameIntervalP?: number;
+    maxNumRefFrames?: number;
+    level?: NvidiaH264Level;
+    profile?: NvidiaH264Profile;
+    outputAud?: boolean;
+    rateControl?: NvidiaRateControl;
+}
+
+/** @public */
+export declare type NvidiaH264Level = 1 | 2 | 2.1 | 3 | 3.1 | 4 | 4.1 | 5 | 5.1 | 5.2 | 6 | 6.1 | 6.2;
+
+/** @public */
+export declare type NvidiaH264Profile = "baseline" | "main" | "high" | "high444";
+
+/** @public */
+export declare interface NvidiaHevc {
+    type: "nv-hevc";
+    preset?: NvidiaPreset;
+    idrPeriod?: number;
+    gopInterval?: number;
+    frameIntervalP?: number;
+    maxNumRefFrames?: number;
+    level?: NvidiaHevcLevel;
+    outputAud?: boolean;
+    tier?: NvidiaHevcTier;
+    profile?: NvidiaHevcProfile;
+    rateControl?: NvidiaRateControl;
+}
+
+/** @public */
+export declare type NvidiaHevcLevel = 1 | 2 | 2.1 | 3 | 3.1 | 4 | 4.1 | 5 | 5.1 | 5.2 | 6 | 6.1 | 6.2;
+
+/** @public */
+export declare type NvidiaHevcProfile = "main" | "main10";
+
+/** @public */
+export declare type NvidiaHevcTier = "main" | "high";
+
+/** @public */
+export declare type NvidiaPreset = "p1" | "p2" | "p3" | "p4" | "p5" | "p6" | "p7";
+
+/** @public */
+export declare interface NvidiaRateControl {
+    mode: NvidiaRateControlMode;
+    averageBitrate: number;
+    maxBitrate?: number;
+    vbvBufferSize?: number;
+    vbvInitialDelay?: number;
+    enableLookahead?: boolean;
+    strictGopTarget?: boolean;
+    lookaheadDepth?: number;
+}
+
+/** @public */
+export declare type NvidiaRateControlMode = "con_stqp" | "vbr" | "cbr";
+
+/** @public */
+export declare interface OffsetRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+/**
+ * @public
+ * Return type to enable control of an RTMP stream once media arrives on it
+ */
+export declare type OnStreamResult = 
+/** Accept the stream */
+    {
+    accept: true;
+    videoStreamKey: StreamKey_2 | StreamKeySettings;
+    audioStreamKey: StreamKey_2 | StreamKeySettings;
+}
+/** Reject the stream */
+| {
+    accept: false;
+    reason: string;
+};
+
+/** @public */
+export declare interface OpusSettings {
+    kind: "opus";
+}
+
+/** @public */
+export declare interface PartTransition {
+    durationMs: number;
+    easing?: SimpleEasing;
+}
+
+/** @public */
+export declare type PinToKey<Pins extends string> = Nullable<Partial<Record<Pins, StreamKey[]>>>;
+
+/** @public */
+export declare type PixelFormat = "bgra" | "rgba" | "yuv420p" | "yuv422p" | "yuv444p" | "yuva420p" | "yuva422p" | "yuva444p";
+
+/** @public */
+export declare interface Processor {
+    cores: Core[];
+}
+
+declare interface ProcessorMediaNode<Pins extends string> extends SourceMediaNode, AutoSinkMediaNode<Pins> {
+}
+
+declare class ProcessorMediaNode<Pins extends string> {
+    constructor(client: MediaClient, subscribeFn: (subscription: Subscription) => void);
+}
+
+/** @public */
+export declare interface ProcessorNodeSettings<T extends MediaNodeState> extends SourceNodeSettings<T> {
+}
+
+/** @public */
+export declare type ReceiveFromAddress<Pins extends string> = {
+    source: SourceMediaNode;
+    sourceSelector: (streams: StreamMetadata[]) => PinToKey<Pins>;
+};
+
+/** @public */
+export declare type ReceiveFromAddressAuto = {
+    source: SourceMediaNode;
+    sourceSelector: (streams: StreamMetadata[]) => StreamKey[];
+};
+
+/** @public */
+export declare interface RemoteInputSettings<T extends MediaNodeState> extends InputSettings<T> {
+    ip: string;
+    port: number;
+}
+
+/** @public */
+export declare interface Resolution {
+    width: number;
+    height: number;
+}
+
+/** @public */
+export declare type RtmpInputStatus = "disconnected";
+
+/**
+ * @public
+ * {@link NorskOutput.rtmp}
+ */
+export declare class RtmpOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface RtmpOutputSettings extends NodeSettings<RtmpOutputNode>, StreamStatsMixin {
+    url: string;
+    numberOfStreams?: number;
+}
+
+/**
+ * @public
+ * {@link NorskInput.rtmpServer}
+ */
+export declare class RtmpServerInputNode extends SourceMediaNode {
+    close(): void;
+    nudge(sourceName: string, programNumber: number, nudge: number): void;
+}
+
+/**
+ * @public
+ * Settings to control how RTMP streams can be included as sources in your media workflow
+ */
+export declare interface RtmpServerInputSettings extends SourceNodeSettings<RtmpServerInputNode>, StreamStatsMixin {
+    /** The port the RTMP server should listen on */
+    port: number;
+    /**
+     * On connect callback, use to accept/reject connections given app/url in use
+     * @eventProperty
+     */
+    onConnection?: (
+    /** The RTMP "app" field from the connection string */
+    app: string, 
+    /** The full URL of the RTMP connection string */
+    url: string) => {
+        accept: true;
+    } | {
+        accept: false;
+        reason: string;
+    };
+    /**
+     * On stream callback, set up the stream keys for a given stream or reject the stream
+     * @eventProperty
+     */
+    onStream?: (
+    /** The RTMP "app" field from the connection string */
+    app: string, 
+    /** The full URL of the RTMP connection string */
+    url: string, 
+    /** The Norsk streamId of this media stream */
+    streamId: number, 
+    /** TODO - publishingName */
+    publishingName: string) => OnStreamResult;
+    /**
+     * Called when the connection status has changed (e.g. when the RTMP connection drops)
+     * @eventProperty
+     */
+    onConnectionStatusChange?: (
+    /** The new connection state */
+    status: RtmpInputStatus, 
+    /** The audio and video stream keys that were present in the stream at the time of the status change */
+    streamKeys: {
+        audioStreamKey: StreamKey_2;
+        videoStreamKey: StreamKey_2;
+    }[]) => void;
+}
+
+/** @public */
+export declare interface RtpEac3 {
+    kind: "eac3";
+    clockRate: number;
+    languageCode?: string;
+    ec3Extension: boolean;
+    complexityIndex: number;
+}
+
+/** @public */
+export declare interface RtpH264 {
+    kind: "h264";
+    clockRate: number;
+}
+
+/** @public */
+export declare interface RtpHEVC {
+    kind: "hevc";
+    clockRate: number;
+}
+
+/**
+ * @public
+ * {@link NorskInput.rtp}
+ */
+export declare class RtpInputNode extends SourceMediaNode {
+    nudge(nudge: number): void;
+    close(): void;
+}
+
+/** @public */
+export declare interface RtpInputSettings extends SourceNodeSettings<RtpInputNode>, StreamStatsMixin {
+    sourceName: string;
+    streams: readonly RtpStreamSettings[];
+}
+
+/** @public */
+export declare interface RtpLinearPcm {
+    kind: "linearpcm";
+    sampleRate: SampleRate;
+    channelLayout: ChannelLayout;
+    bitDepth: RtpLinearPcmBitDepth;
+}
+
+/** @public */
+export declare type RtpLinearPcmBitDepth = 16 | 24;
+
+/** @public */
+export declare interface RtpMpeg4GenericAacHbr {
+    kind: "mpeg4-generic-aac-hbr";
+    config: string;
+}
+
+/** @public */
+export declare interface RtpStreamSettings {
+    streamId: number;
+    ip: string;
+    iface: string;
+    rtpPort: number;
+    rtcpPort: number;
+    streamType: RtpLinearPcm | RtpEac3 | RtpMpeg4GenericAacHbr | RtpH264 | RtpHEVC;
+}
+
+/** @public */
+export declare interface SampleAspectRatio {
+    x: number;
+    y: number;
+}
+
+/** @public */
+export declare type SampleFormat = "flt" | "fltp" | "s16" | "s16p";
+
+/** @public Audio sample rate, in Hz */
+export declare type SampleRate = 8000 | 11025 | 12000 | 16000 | 22050 | 24000 | 32000 | 44100 | 48000 | 64000 | 88200 | 96000;
+
+/** @public */
+export declare function selectAllAudios(count: number): (streams: readonly StreamMetadata[]) => StreamKey[];
+
+/** @public */
+export declare function selectAllVideos(count: number): (streams: readonly StreamMetadata[]) => StreamKey[];
+
+/** @public */
+export declare function selectAudio(streams: readonly StreamMetadata[]): StreamKey[];
+
+/**
+ * @public
+ * Select all the audio and video streams from the input
+ * @param streams - The streams from the inbound Context
+ * @returns Array of selected StreamKeys
+ */
+export declare function selectAV(streams: readonly StreamMetadata[]): StreamKey[];
+
+/** @public */
+export declare function selectSubtitles(streams: readonly StreamMetadata[]): StreamKey[];
+
+/** @public */
+export declare function selectVideo(streams: readonly StreamMetadata[]): StreamKey[];
+
+/** @public */
+export declare type SentenceBuildMode = "raw" | "stable" | "partial" | "complete";
+
+/** @public */
+export declare type SimpleEasing = "linear" | "ease_in" | "ease_in_out" | "ease_out";
+
+/** @public */
+export declare interface SingleStreamStats extends StreamStats {
+    streamKey: StreamKey;
+    metadata: StreamMetadataMessage;
+}
+
+/** @public */
+export declare class SinkMediaNode<Pins extends string> extends MediaNodeState {
+    /** Subscribe to the given sources,
+     * This version of the function call accepts the target pins of an output
+     * and is suitable for advanced use where a node is capable of subscribing to
+     * multiple video streams and provides a means of distinguishing them via pins
+     * discarding any existing subscriptions */
+    subscribeToPins(sources: ReceiveFromAddress<Pins>[], validation?: (context: Context) => boolean): void;
+    sourceContextChange(responseCallback: () => void): Promise<void>;
+}
+
+/**
+ * @public
+ * {@link NorskControl.smoothSwitcher}
+ */
+export declare class SmoothSwitcherNode<Pins extends string> extends ProcessorMediaNode<Pins> {
+    switchSource(newSource: Pins): void;
+    close(): void;
+}
+
+/** @public */
+export declare interface SmoothSwitcherSettings<Pins extends string> extends ProcessorNodeSettings<SmoothSwitcherNode<Pins>> {
+    activeSource?: Pins;
+    outputSource: string;
+    transitionDurationMs?: number;
+    outputResolution: Resolution;
+    sampleRate: SampleRate;
+}
+
+/** @public */
+export declare class SourceMediaNode extends MediaNodeState {
+    outputStreams: StreamMetadata[];
+    registerForContextChange(subscriber: SinkMediaNode<string>): void;
+    unregisterForContextChange(subscriber: SinkMediaNode<string>): void;
+}
+
+/** @public */
+export declare interface SourceNodeSettings<T extends MediaNodeState> extends NodeSettings<T> {
+    onOutboundContextChange?: (streams: StreamMetadata[]) => Promise<void>;
+}
+
+/**
+ * @public
+ */
+export declare type SrtConnectionResult = 
+/** Accept the stream */
+    {
+    accept: true;
+    sourceName: string;
+}
+/** Reject the stream */
+| {
+    accept: false;
+};
+
+/**
+ * @public
+ * {@link NorskInput.srt}
+ */
+export declare class SrtInputNode extends SourceMediaNode {
+    nudge(sourceName: string, programNumber: number, nudge: number): void;
+    closeStream(streamIndex: number): void;
+    close(): void;
+}
+
+/**
+ * @public
+ */
+export declare interface SrtInputSettings extends RemoteInputSettings<SrtInputNode>, StreamStatsMixin {
+    mode: SrtMode;
+    /**
+     * Passphrase for encryption
+     */
+    passphrase?: string;
+    /**
+     * Stream ID to set on the socket when acting in caller mode
+     */
+    streamId?: string;
+    /**
+     * On connect callback, notifying that a new caller has connected (in listener mode) and set the source name accordingly
+     * @eventProperty
+     */
+    onConnection?: (
+    /** The stream_id sent on the SRT socket (or empty if none was set) */
+    streamId: string, 
+    /** The connection index */
+    index: number, 
+    /** Remote host address */
+    remoteHost: string) => SrtConnectionResult;
+    /**
+     * Called when the connection status has changed (e.g. when the SRT socket is closed)
+     * @eventProperty
+     */
+    onConnectionStatusChange?: (
+    /** The new connection state */
+    status: SrtInputStatus, 
+    /** The source name assigned to the connection which changed status */
+    sourceName: string | undefined) => void;
+}
+
+/** @public */
+export declare type SrtInputStatus = "disconnected";
+
+/** @public */
+export declare type SrtMode = "listener" | "caller";
+
+/**
+ * @public
+ * {@link NorskOutput.srt}
+ */
+export declare class SrtOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface SrtOutputSettings extends NodeSettings<SrtOutputNode>, StreamStatsMixin {
+    /**
+     * Passphrase for encryption
+     */
+    passphrase?: string;
+    /**
+     * Stream ID to set on the socket when acting in caller mode
+     */
+    streamId?: string;
+    mode: SrtMode;
+    ip: string;
+    port: number;
+    /**
+     * On connect callback, notifying that a new caller has connected (in listener mode) and providing the stream_id that was set on the socket
+     * @eventProperty
+     */
+    onConnection?: (
+    /** The stream_id sent on the SRT socket (or empty if none was set) */
+    streamId: string, 
+    /** The stream index (count of connections that have been made) */
+    streamIndex: number, 
+    /** The remote host address */
+    remoteHost: string) => void;
+}
+
+/** @public */
+export declare type StabilizationMode = "low" | "medium" | "high";
+
+/** @public */
+export declare interface StreamKey {
+    streamId: number;
+    programNumber: number;
+    sourceName: string;
+    renditionName: string;
+}
+
+/**
+ * @public
+ * {@link NorskTransform.streamKeyOverride}
+ */
+export declare class StreamKeyOverrideNode extends AutoProcessorMediaNode<"audio" | "video" | "subtitle"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface StreamKeyOverrideSettings extends ProcessorNodeSettings<StreamKeyOverrideNode> {
+    streamKey: StreamKey;
+}
+
+/** @public */
+export declare interface StreamKeySettings {
+    /**  Source name. Default: the rtmp app */
+    sourceName?: string;
+    /** Program number. Default: 1 */
+    programNumber?: number;
+    /** Stream Id. Default: 1 for audio, 2 for video */
+    streamId?: number;
+    /** Rendition name. Default: the stream publishing name */
+    renditionName?: string;
+}
+
+/** @public */
+export declare interface StreamMetadata {
+    streamKey?: StreamKey;
+    message: StreamMetadataMessage;
+}
+
+/** @public */
+export declare type StreamMetadataMessage = {
+    case: "audio";
+    value: AudioStreamMetadata;
+} | {
+    case: "video";
+    value: VideoStreamMetadata;
+} | {
+    case: "subtitle";
+    value: SubtitleStreamMetadata;
+} | {
+    case: undefined;
+    value?: undefined;
+};
+
+/** @public */
+export declare interface StreamStats {
+    /** The size of the sample window in seconds */
+    sampleSizeSeconds: number;
+    /** The number of bits over the sample window */
+    bitsForSample: number;
+    /** The bitrate, in bits per second */
+    bitrate: number;
+    /** The number of frames over the sample window */
+    framesForSample: number;
+    /** The frame rate, in frames per second */
+    framerate: number;
+    /** The number of key frames over the sample window */
+    keyFramesForSample: number;
+}
+
+/** @public */
+export declare interface StreamStatsMixin {
+    /**
+     * Sampling rates for stream stats, in seconds
+     */
+    statsSampling?: PlainMessage<StreamStatsSampling>;
+    /**
+     * Called at periodic intervals when stream statistics are ready.
+     * @eventProperty
+     */
+    onStreamStats?: (
+    /** The stats */
+    stats: MultiStreamStats) => void;
+}
+
+/**
+ * @public
+ * Monitor statistics about a media stream. Create a new instance of this node with {@link NorskControl.streamStats}.
+ */
+export declare class StreamStatsNode extends AutoProcessorMediaNode<"audio" | "video"> {
+    close(): void;
+}
+
+/**
+ * @public
+ * Settings for an {@link StreamStatsNode}
+ */
+export declare interface StreamStatsSettings extends ProcessorNodeSettings<StreamStatsNode>, StreamStatsMixin {
+    /**
+     * Called periodically with the stream stats
+     * @param stats - The statistics for the stream
+     * @eventProperty
+     */
+    onStreamStats: (stats: MultiStreamStats) => void;
+    /**
+     * Sampling rates for stream stats, in seconds
+     */
+    statsSampling?: PlainMessage<StreamStatsSampling>;
+}
+
+/** @public */
+export declare const subtitlesToPin: <Pins extends string>(pin: Pins) => (streams: StreamMetadata[]) => PinToKey<Pins>;
+
+/**
+ * @public
+ * Returns the stream keys for subtitle streams in a media context
+ * @param streams - The media context from which to return the stream keys
+ * @returns The subtitle stream keys in the media context
+ */
+export declare function subtitleStreamKeys(streams: readonly StreamMetadata[]): StreamKey[];
+
+/** @public */
+export declare interface SubtitleStreamMetadata {
+}
+
+/**
+ * @public
+ * Filters a context to only the subtitle streams within it
+ * @param streams - The media context from which to return the streams
+ * @returns The subtitle streams in the media context
+ */
+export declare function subtitleStreams(streams: readonly StreamMetadata[]): StreamMetadata[];
+
+/**
+ * @public
+ * {@link NorskTransform.sync}
+ */
+export declare class SyncNode extends AutoProcessorMediaNode<"audio" | "video"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface SyncSettings extends ProcessorNodeSettings<SyncNode> {
+}
+
+/**
+ * @public
+ * {@link NorskTransform.timestampNudge}
+ */
+export declare class TimestampNudgerNode extends AutoProcessorMediaNode<"audio" | "video"> {
+    nudge(nudge: number): void;
+    close(): void;
+}
+
+/** @public */
+export declare interface TimestampNudgerSettings extends ProcessorNodeSettings<TimestampNudgerNode> {
+    nudge?: number;
+}
+
+declare class TsCommonInputNode<SourceMessage, T extends SourceMediaNode> extends SourceMediaNode {
+    constructor(tsType: TsInputType, client: MediaClient, settings: SourceNodeSettings<T> & StreamStatsMixin, nudgeFn: (nudge: TimestampProgramNudge) => SourceMessage, onEof: (() => void) | undefined, grpcStartFn: () => grpc.ClientDuplexStream<SourceMessage, TsInputEvent>);
+    nudge(programNumber: number, nudge: number): void;
+    close(): void;
+}
+
+/**
+ * @public
+ * {@link NorskInput.localTsFile}
+ */
+export declare class TsFileInputNode extends TsCommonInputNode<TsFileInputMessage, TsFileInputNode> {
+}
+
+/**
+ * @public
+ * {@link NorskOutput.localTsFile}
+ */
+export declare class TsFileOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface TsFileOutputSettings extends NodeSettings<TsFileOutputNode>, StreamStatsMixin {
+    fileName: string;
+}
+
+declare enum TsInputType {
+    TsFile = 0,
+    Srt = 1,
+    Udp = 2,
+    M3u8 = 3
+}
+
+/**
+ * @public
+ * {@link NorskOutput.tsUdp}
+ */
+export declare class TsUdpOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface TsUdpOutputSettings extends NodeSettings<TsUdpOutputNode>, StreamStatsMixin {
+    destinationIp: string;
+    iface: string;
+    port: number;
+}
+
+/**
+ * @public
+ * {@link NorskInput.udpTs}
+ */
+export declare class UdpTsInputNode extends TsCommonInputNode<UdpTsInputMessage, UdpTsInputNode> {
+}
+
+/** @public */
+export declare interface UdpTsInputSettings extends RemoteInputSettings<UdpTsInputNode> {
+}
+
+/** @public */
+export declare interface UpdateCredentials {
+    destinationId: string;
+    awsCredentials: AwsCredentials;
+}
+
+export { Version }
+
+/**
+ * @public
+ * {@link NorskTransform.videoEncodeLadder}
+ */
+export declare class VideoEncodeLadderNode extends AutoProcessorMediaNode<"video"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface VideoEncodeLadderRung {
+    name: string;
+    width: number;
+    height: number;
+    frameRate?: FrameRate;
+    /**
+     * Specifies the input video's Sample Aspect Ratio (SAR) to be used by the
+     * encoder in width:height
+     */
+    sar?: SampleAspectRatio;
+    codec: X264Codec | X265Codec | NvidiaH264 | NvidiaHevc | NetintH264 | NetintHevc;
+}
+
+/** @public */
+export declare interface VideoEncodeLadderSettings extends ProcessorNodeSettings<VideoEncodeLadderNode> {
+    rungs: readonly VideoEncodeLadderRung[];
+}
+
+/**
+ * @public
+ * Returns the stream keys for video streams in a media context
+ * @param streams - The media context from which to return the stream keys
+ * @returns The video stream keys in the media context
+ */
+export declare function videoStreamKeys(streams: readonly StreamMetadata[]): StreamKey[];
+
+/** @public */
+export declare interface VideoStreamMetadata {
+    codec: string;
+    width: number;
+    height: number;
+}
+
+/**
+ * @public
+ * Filters a context to only the video streams within it
+ * @param streams - The media context from which to return the streams
+ * @returns The video streams in the media context
+ */
+export declare function videoStreams(streams: readonly StreamMetadata[]): StreamMetadata[];
+
+/** @public */
+export declare const videoToPin: <Pins extends string>(pin: Pins) => (streams: StreamMetadata[]) => PinToKey<Pins>;
+
+/**
+ * @public
+ * {@link NorskTransform.videoTransform}
+ */
+export declare class VideoTransformNode extends AutoProcessorMediaNode<"video"> {
+    close(): void;
+}
+
+/** @public */
+export declare interface VideoTransformSettings extends ProcessorNodeSettings<VideoTransformNode> {
+    resolution?: Resolution;
+    frameRate?: FrameRate;
+    sar?: SampleAspectRatio;
+}
+
+/**
+ * @public
+ * {@link NorskOutput.webRTCWhip}
+ */
+export declare class WebRTCWhipOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+    close(): void;
+}
+
+/**
+ * @public
+ */
+export declare interface WebRTCWhipOutputSettings extends NodeSettings<WebRTCWhipOutputNode>, StreamStatsMixin {
+    uri: string;
+    authHeader: string;
+}
+
+/**
+ * @public
+ * {@link NorskInput.localWebVttFile}
+ */
+export declare class WebVttFileInputNode extends SourceMediaNode {
+    close(): void;
+}
+
+/**
+ * @public
+ * {@link NorskInput.whip}
+ */
+export declare class WhipInputNode extends SourceMediaNode {
+    nudge(sourceName: string, programNumber: number, nudge: number): void;
+    close(): void;
+}
+
+/** @public */
+export declare interface WhipInputSettings extends InputSettings<WhipInputNode>, StreamStatsMixin {
+}
+
+/** @public */
+export declare interface X264Codec {
+    type: "x264";
+    threads?: number;
+    /**
+     * Rate control options - one of abr, cqp or crf
+     */
+    bitrateMode?: BitrateMode;
+    /**
+     * Set the H264 profile of the output
+     */
+    profile?: X264Profile;
+    /**
+     * Sets the level flag in the output
+     */
+    level?: X264Level;
+    /**
+     * Sets the minimum length between IDR frames
+     */
+    keyFrameIntervalMin?: number;
+    /**
+     * Sets the maximum length between IDR frames
+     */
+    keyFrameIntervalMax?: number;
+    /**
+     * Sets the maximum number of concurrent B-frames
+     */
+    bframes?: number;
+    /**
+     * Tune options to further optimize them for your input content. If you
+     * specify a tuning, the changes will be applied after 'preset' but before all
+     * other parameters.
+     */
+    tune?: X264Tune;
+    /**
+     * Change options to trade off compression efficiency against encoding speed.
+     * If you specify a preset, the changes it makes will be applied before all
+     * other parameters are applied.
+     */
+    preset?: X264Preset;
+    /**
+     * Maximum number of reference frames, i.e., the number of previous frames
+     * each P-frame can use as references
+     */
+    frameReference?: number;
+    /**
+     * Enables CABAC (Context Adaptive Binary Arithmetic Coder) stream compression
+     * instead of the less efficient CAVLC (Context Adaptive Variable Length
+     * Coder) system. Significantly improves both the compression efficiency
+     * (10-20% typically) and the decoding requirements, at the expense of encode
+     * CPU requirements
+     */
+    cabac?: boolean;
+    /**
+     * Sets the maximum rate the VBV buffer should be assumed to refill at
+     */
+    vbvMaxRate?: number;
+    /**
+     * Sets the size of the VBV buffer in kilobits
+     */
+    vbvBufferSize?: number;
+    /**
+     * Sets the threshold for I/IDR frame placement.  Setting sceneCut to zero
+     * disables adaptive I-frame decisioning
+     */
+    sceneCut?: number;
+    /**
+     * Use access unit delimiters in the output
+     */
+    aud?: boolean;
+    /**
+     * Disables the loop filter. Not Recommended.
+     */
+    noDeblock?: boolean;
+    /**
+     * Signal HRD information
+     */
+    nalHrd?: X264NalHrd;
+}
+
+/** @public */
+export declare type X264Level = 1 | 1.1 | 1.2 | 1.3 | 2 | 2.1 | 2.2 | 3 | 3.1 | 3.2 | 4 | 4.1 | 4.2 | 5 | 5.1;
+
+/**
+ * @public
+ * Three possible values:
+ * - "none": specify no HRD information
+ * - "vbr": specify HRD information
+ * - "cbr": specify HRD information and pack the bitstream to the bitrate specified
+ */
+export declare type X264NalHrd = "none" | "vbr" | "cbr";
+
+/** @public */
+export declare type X264Preset = "ultrafast" | "superfast" | "veryfast" | "faster" | "fast" | "medium" | "slow" | "slower" | "veryslow" | "placebo";
+
+/** @public */
+export declare type X264Profile = "baseline" | "main" | "high" | "high10" | "high422" | "high444";
+
+/** @public */
+export declare type X264Tune = "film" | "animation" | "grain" | "stillimage" | "psnr" | "ssim" | "fastdecode" | "zerolatency";
+
+/** @public X265 codec */
+export declare interface X265Codec {
+    type: "x265";
+    threads?: number;
+    bitrateMode?: BitrateMode;
+    profile?: X265Profile;
+    /**
+     * Sets the level flag in the output
+     */
+    level?: X265Level;
+    /**
+     * Sets the minimum length between IDR frames
+     */
+    keyFrameIntervalMin?: number;
+    /**
+     * Sets the maximum length between IDR frames
+     */
+    keyFrameIntervalMax?: number;
+    /**
+     * Sets the maximum number of concurrent B-frames
+     */
+    bframes?: number;
+    /**
+     * Tune options to further optimize them for your input content. If you
+     * specify a tuning, the changes will be applied after 'preset' but before all
+     * other parameters.
+     */
+    tune?: X265Tune;
+    /**
+     * Change options to trade off compression efficiency against encoding speed.
+     * If you specify a preset, the changes it makes will be applied before all
+     * other parameters are applied.
+     */
+    preset?: X265Preset;
+    /**
+     * Maximum number of reference frames, i.e., the number of previous frames
+     * each P-frame can use as references
+     */
+    frameReference?: number;
+    /**
+     * Sets the maximum rate the VBV buffer should be assumed to refill at
+     */
+    vbvMaxRate?: number;
+    /**
+     * Sets the size of the VBV buffer in kilobits
+     */
+    vbvBufferSize?: number;
+    /**
+     * Sets the threshold for I/IDR frame placement.  Setting sceneCut to zero
+     * disables adaptive I-frame decisioning
+     */
+    sceneCut?: number;
+    /**
+     * Use access unit delimiters in the output
+     */
+    aud?: boolean;
+    /**
+     * Disables the loop filter. Not Recommended.
+     */
+    noDeblock?: boolean;
+}
+
+/** @public */
+export declare type X265Level = 1 | 2 | 2.1 | 3 | 3.1 | 4 | 4.1 | 5 | 5.1 | 5.2 | 6 | 6.1 | 6.2;
+
+/** @public */
+export declare type X265Preset = "ultrafast" | "superfast" | "veryfast" | "faster" | "fast" | "medium" | "slow" | "slower" | "veryslow" | "placebo";
+
+/** @public */
+export declare type X265Profile = "main" | "main10" | "main444_8" | "main422_10" | "main444_10";
+
+/** @public */
+export declare type X265Tune = "psnr" | "ssim" | "grain" | "zerolatency" | "fastdecode" | "animation";
+
+export { }