@norskvideo/norsk-sdk 1.0.349 → 1.0.351

package/dist/norsk-sdk.d.ts

@@ -0,0 +1,4957 @@
+/// <reference types="node" />
+
+import { AudioCodec } from '@norskvideo/norsk-api/lib/media_pb';
+import { CmafAudioMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { CmafMultiVariantMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { CmafVideoMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { CmafWebVttMessage } 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 { FileTsInputMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { FrameRate as FrameRate_2 } from '@norskvideo/norsk-api/lib/media_pb';
+import { GopStructure } from '@norskvideo/norsk-api/lib/media_pb';
+import * as grpc from '@grpc/grpc-js';
+import { HlsOutputEvent } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsTsAudioMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsTsCombinedPushMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsTsMultiVariantMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { HlsTsVideoMessage } 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 { Readable } from 'stream';
+import { RtmpError_UnsupportedAudio } from '@norskvideo/norsk-api/lib/media_pb';
+import { RtmpError_UnsupportedVideo } from '@norskvideo/norsk-api/lib/media_pb';
+import { Scte35SpliceInfoSection as Scte35SpliceInfoSection_2 } from '@norskvideo/norsk-api/lib/media_pb';
+import { StreamKey as StreamKey_2 } from '@norskvideo/norsk-api/lib/media_pb';
+import { StreamStatisticsSampling } 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 { TsInputEvent } from '@norskvideo/norsk-api/lib/media_pb';
+import { UdpTsInputMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { VancPayloadFormat as VancPayloadFormat_2 } 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';
+import { Writable } from 'stream';
+
+/** @public */
+export declare type AacProfile = "lc" | "main" | "high";
+
+/**
+ * @public
+ * Settings for an AAC encode
+ * see: {@link NorskTransform.audioEncode}
+ */
+export declare interface AacSettings {
+    kind: "aac";
+    /** The output sample rate of this AAC encode */
+    sampleRate: SampleRate;
+    /** The AAC profile of this AAC encode */
+    profile: AacProfile;
+}
+
+/** @public */
+export declare interface AdMarker {
+    id: string;
+    startDate: Date;
+    durationSeconds: number;
+    scte35: Scte35SpliceInfoSection;
+}
+
+export declare class AncillaryNode extends AutoProcessorMediaNode<"ancillary"> {
+    sendScte35(key: StreamKey, info: Scte35SpliceInfoSection_2): void;
+}
+
+export declare interface AncillarySettings extends ProcessorNodeSettings<AncillaryNode> {
+    onScte35?: (stream: StreamKey, message: Scte35SpliceInfoSection_2) => void;
+    onSmpte2038?: (stream: StreamKey, message: Smpte2038Message) => void;
+}
+
+/**
+ * @public
+ * Returns the stream keys for ancillary streams in a media context
+ * @param streams - The media context from which to return the stream keys
+ * @returns The ancillary stream keys in the media context
+ */
+export declare function ancillaryStreamKeys(streams: readonly StreamMetadata[]): StreamKey[];
+
+/** @public */
+export declare interface AncillaryStreamMetadata {
+}
+
+/**
+ * @public
+ * Filters a context to only the ancillary streams within it
+ * @param streams - The media context from which to return the streams
+ * @returns The ancillary streams in the media context
+ */
+export declare function ancillaryStreams(streams: readonly StreamMetadata[]): StreamMetadata[];
+
+/**
+ * @public
+ * see: {@link NorskTransform.audioBuildMultichannel}
+ */
+export declare class AudioBuildMultichannelNode extends AutoProcessorMediaNode<"audio"> {
+}
+
+/**
+ * @public
+ * Settings for an Audio Build Multichannel Node
+ * see: {@link NorskTransform.audioBuildMultichannel}
+ * */
+export declare interface AudioBuildMultichannelSettings extends ProcessorNodeSettings<AudioBuildMultichannelNode> {
+    /** The channel layout of the built outgoing stream */
+    channelLayout: ChannelLayout;
+    sampleRate: SampleRate;
+    /**
+     * Stream keys specifying the source for each channel, where the order is
+     * significant. The streams must all have the same sample format and sample
+     * rate.
+     */
+    channelList: readonly StreamKey[];
+    /**
+     * Callback invoked when the inbound context changes
+     * a new channel list can be returned here that overrides the initial configuration
+     * and allows the channel order to be changed at runtime
+     */
+    onInputChanged?: (keys: StreamKey[]) => StreamKey[] | undefined;
+    /** The stream key to use for the outoging stream*/
+    outputStreamKey: StreamKey;
+}
+
+export { AudioCodec }
+
+/**
+ * @public
+ * see: {@link NorskTransform.audioEncode}
+ */
+export declare class AudioEncodeNode extends AutoProcessorMediaNode<"audio"> {
+}
+
+/**
+ * @public
+ * Settings for an audio encode
+ * see: {@link NorskTransform.audioEncode}
+ * */
+export declare interface AudioEncodeSettings extends ProcessorNodeSettings<AudioEncodeNode> {
+    /**
+     * The channel layout of this encode
+     * Note: If the channel layout doesn't match then it will be automatically converted
+     * to gain greater control over this process, see {@link NorskTransform.audioMix} and {@link NorskTransform.audioMixMatrix}
+     * */
+    channelLayout: ChannelLayout;
+    /** The target bitrate of this encode  */
+    bitrate: number;
+    /** The name given to the rendition portion of the stream key assigned to this node's output */
+    outputRenditionName: string;
+    /** What codec to (re) encode the audio to */
+    codec: OpusSettings | AacSettings;
+}
+
+/**
+ * @public
+ * see: {@link NorskTransform.audioGain}
+ */
+export declare class AudioGainNode extends AutoProcessorMediaNode<"audio"> {
+    /**
+     * @public
+     * Updates the config of this AudioGain node for all subsequent frames
+     * this allows the user to change the gains in the outgoing stream
+     * dynamically as the stream progresses
+     * @param settings - The updated settings
+     */
+    updateConfig(settings: AudioGainSettingsUpdate): void;
+}
+
+/**
+ * @public
+ * Settings for an Audio Gain node
+ * see: {@link NorskTransform.audioGain}
+ * */
+export declare interface AudioGainSettings extends ProcessorNodeSettings<AudioGainNode> {
+    /** A vector of gains for this source, one for each channel */
+    channelGains: readonly Gain[];
+}
+
+/**
+ * @public
+ * An update operation for an Audio Gain node
+ * see: {@link AudioGainNode.updateConfig}
+ * */
+export declare interface AudioGainSettingsUpdate {
+    /** A vector of gains for this source, one for each channel */
+    channelGains?: readonly Gain[];
+}
+
+/** @public */
+export declare interface AudioMeasureLevels {
+    stream: StreamKey;
+    pts: Interval;
+    channelLevels: ChannelLevels[];
+}
+
+/**
+ * @public
+ * see: {@link NorskControl.audioMeasureLevels}.
+ */
+export declare class AudioMeasureLevelsNode extends AutoProcessorMediaNode<"audio"> {
+}
+
+/**
+ * @public
+ * Settings for an AudioMeasureLevelsNode
+ * see: {@link NorskControl.audioMeasureLevels}
+ */
+export declare interface AudioMeasureLevelsSettings extends ProcessorNodeSettings<AudioMeasureLevelsNode> {
+    /**
+     * Called with the audio level data
+     * @param levels - The level data for the audio stream
+     * @eventProperty
+     */
+    onData: (levels: AudioMeasureLevels) => void;
+    intervalFrames?: number;
+}
+
+/**
+ * @public
+ * see: {@link NorskTransform.audioMixMatrix}
+ */
+export declare class AudioMixMatrixNode extends AutoProcessorMediaNode<"audio"> {
+    /**
+     * @public
+     * Updates the config of this AudioMixMatrix node for all subsequent frames
+     * this allows the user to change the gains in the outgoing mix
+     * dynamically as the stream progresses
+     * @param settings - The updated settings
+     */
+    updateConfig(settings: AudioMixMatrixSettingsUpdate): void;
+}
+
+/**
+ * @public
+ * Settings for the Audio Mix Matrix Node
+ * see: {@link NorskTransform.audioMixMatrix}
+ * */
+export declare interface AudioMixMatrixSettings extends ProcessorNodeSettings<AudioMixMatrixNode> {
+    /** 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 AudioMixMatrixNode}.
+ * Call {@link AudioMixMatrixNode.updateConfig} for updating the config.
+ */
+export declare interface AudioMixMatrixSettingsUpdate {
+    /** The NxM updated matrix of gains from N input channels to M output channels */
+    channelGains: readonly Gain[][];
+}
+
+/**
+ * @public
+ * see: {@link NorskTransform.audioMix}
+ */
+export declare class AudioMixNode<Pins extends string> extends ProcessorMediaNode<Pins> {
+    /**
+     * @public
+     * Updates the config of this AudioMix for all subsequent frames
+     * this allows the user to change the levels and sources in the outgoing mix
+     * dynamically as the stream progresses
+     * @param settings - The updated settings
+     */
+    updateConfig(settings: AudioMixSettingsUpdate<Pins>): void;
+}
+
+/**
+ * @public
+ * The settings for an AudioMix operation
+ * see: {@link NorskTransform.audioMix}
+ * */
+export declare interface AudioMixSettings<Pins extends string> extends ProcessorNodeSettings<AudioMixNode<Pins>> {
+    /** The audio sources to mix */
+    sources: readonly AudioMixSource<Pins>[];
+    /** The source name to use for the output stream */
+    outputSource: string;
+    /** The channel layout that the mixer runs at
+     * all audio streams will be normalised to this value and therefore
+     * this will be the output channel layout of this node */
+    channelLayout: ChannelLayout;
+    /** The sample rate that the mixer runs at
+     * all audio streams will be normalised to this value and therefore
+     * this will be the output sample rate of this node */
+    sampleRate?: SampleRate;
+}
+
+/**
+ * @public
+ * An update operation for an AudioMix node
+ * see: {@link AudioMixNode.updateConfig}
+ * */
+export declare interface AudioMixSettingsUpdate<Pins extends string> {
+    /** The audio sources to mix along with their potentially new gain values */
+    sources: readonly AudioMixSource<Pins>[];
+}
+
+/**
+ * @public
+ * The settings for a single source within an AudioMix operation
+ * see: {@link NorskTransform.audioMix}
+ * */
+export declare interface AudioMixSource<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
+ * see: {@link NorskInput.audioSignal}
+ */
+export declare class AudioSignalGeneratorNode extends SourceMediaNode {
+}
+
+/**
+ * @public
+ * Settings for an Audio Signal Generator
+ * see: {@link NorskInput.audioSignal}
+ * */
+export declare interface AudioSignalGeneratorSettings extends SourceNodeSettings<AudioSignalGeneratorNode> {
+    /** The source name to set in the stream key of the outgoing stream */
+    sourceName: string;
+    /** The audio channel layout of the generated stream */
+    channelLayout: ChannelLayout;
+    /** The sample rate of the generated stream */
+    sampleRate: SampleRate;
+    /** The sample format to use.  Default: "fltp"  */
+    sampleFormat?: SampleFormat;
+    /**
+     * Waveform - create one with {@link mkSine}
+     * */
+    wave?: Wave;
+}
+
+/**
+ * @public
+ * see: {@link NorskTransform.audioSplitMultichannel}
+ */
+export declare class AudioSplitMultichannelNode extends AutoProcessorMediaNode<"audio"> {
+}
+
+/**
+ * @public
+ * Settings for an Audio Split Multichannel node
+ * see: {@link NorskTransform.audioSplitMultichannel}
+ * */
+export declare interface AudioSplitMultichannelSettings extends ProcessorNodeSettings<AudioSplitMultichannelNode> {
+    /**
+     * The output stream key of the first channel
+     * subsequent channels will have streamId incremented by N
+     */
+    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 function audioToPin<Pins extends string>(pin: Pins): (streams: StreamMetadata[]) => PinToKey<Pins>;
+
+/**
+ * @public
+ * see: {@link NorskTransform.audioTranscribeAws}
+ */
+export declare class AudioTranscribeAwsNode extends AutoProcessorMediaNode<"audio"> {
+}
+
+/**
+ * @public
+ * Settings for an Audio Transcribe operation using AWS
+ * see: {@link NorskTransform.audioTranscribeAws}
+ * */
+export declare interface AudioTranscribeAwsSettings extends ProcessorNodeSettings<AudioTranscribeAwsNode> {
+    /** Region for the transcribe endpoint */
+    awsRegion: string;
+    /** the stream id to allocate to the outgoing stream*/
+    outputStreamId: number;
+    /** the language that we want to transcribe (also put in the outgoing metadata) */
+    language: string;
+    /** The mode to be used for building sentences */
+    sentenceBuildMode: SentenceBuildMode;
+    /** The mode to be used for stabilising sentences */
+    sentenceStabilizationMode: StabilizationMode;
+    /** The AWS credentials to use for this operation
+     * If not supplied, the standard environment variables will be used if present
+     * */
+    awsCredentials?: AwsCredentials;
+}
+
+/**
+ * @public
+ * see: {@link NorskTransform.audioTranscribeAws}
+ */
+export declare class AudioTranscribeAzureNode extends AutoProcessorMediaNode<"audio"> {
+}
+
+/**
+ * @public
+ * Settings for an audio transcribe/translate operation using Azure Speech Service
+ * see: {@link NorskTransform.audioTranscribeAzure}
+ * */
+export declare interface AudioTranscribeAzureSettings extends ProcessorNodeSettings<AudioTranscribeAzureNode> {
+    outputStreamId: number;
+    sourceLanguage: string;
+    targetLanguages?: string[];
+    /** Key for the Azure Speech Service endpoint */
+    azureKey: string;
+    /** Region for the Azure Speech Service endpoint */
+    azureRegion: string;
+    maximumLineLength: undefined | number;
+}
+
+/**
+ * @public
+ * see: {@link NorskTransform.audioTranscribeAws}
+ */
+export declare class AudioTranscribeWhisperNode extends AutoProcessorMediaNode<"audio"> {
+}
+
+/**
+ * @public
+ * Settings for an Audio Transcribe operation using Whisper sdk
+ * see: {@link NorskTransform.audioTranscribeWhisper}
+ * */
+export declare interface AudioTranscribeWhisperSettings extends ProcessorNodeSettings<AudioTranscribeWhisperNode> {
+    outputStreamId: number;
+    stepMs?: number;
+    lengthMs?: number;
+    keepMs?: number;
+    maxTokens?: number;
+    speedUp?: boolean;
+    noFallback?: boolean;
+    numThreads?: number;
+    useGpu?: boolean;
+    language?: string;
+    model: string;
+    translate?: boolean;
+    tinyDiarize?: boolean;
+    initialPrompt?: string;
+    suppressNonSpeechTokens?: boolean;
+    samplingStrategy?: WhisperSamplingStrategy;
+}
+
+export declare interface AutoProcessorMediaNode<Pins extends string> extends SourceMediaNode, AutoSinkMediaNode<Pins> {
+}
+
+export declare class AutoProcessorMediaNode<Pins extends string> {
+    constructor(client: MediaClient, _unregisterNode: (node: MediaNodeState) => void, getGrpcStream: () => (Readable | Writable), subscribeFn: (subscription: Subscription) => Promise<boolean>, subscribeErrorFn?: (error: SubscriptionError) => void, subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => 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.
+     *
+     * @param done - will be called with no arguments if the subscription succeeds,
+     * or an error if it failed. This error indicates the specific reason it
+     * failed, so you can take appropriate actions in response. It will be called
+     * before the `subscribedStreamsChangedFn` or `subscribeErrorFn` callbacks
+     * provided in the config for the node.
+     *
+     * Errors are also logged to the debug log.
+     */
+    subscribe(sources: ReceiveFromAddressAuto[], validation?: (context: Context) => SubscriptionValidationResponse, done?: (error?: SubscriptionError) => void): void;
+}
+
+/** @public */
+export declare function avToPin<Pins extends string>(pin: Pins): (streams: StreamMetadata[]) => PinToKey<Pins>;
+
+/** @public */
+export declare interface AwsCredentials {
+    accessKey: string;
+    secretKey: string;
+    sessionToken: string;
+}
+
+/**
+ * @public
+ * Configuration for pushing a segmented media stream directly to AWS S3
+ * */
+export declare interface AwsS3PushDestinationSettings {
+    type: "s3";
+    /** The hostname of the s3 server being pushed to. */
+    host: string;
+    /** the port of the s3 server being pushed to. */
+    port: number;
+    /** the path under which segments and playlists will be pushed to */
+    pathPrefix: string;
+    /**
+     * Optionally supply a string that will be inserted into the path structure for segments published in this stream
+     *
+     * This is useful for stream restarts or republishing when duplicate segment IDs would be generated causing problems with
+     * cacheing directives
+     */
+    sessionId?: string;
+    /**
+     * A unique identifier for this destination
+     *
+     * This can be used for supplying updates to configuration to this destination specifically
+     * see: {@link UpdateCredentials}
+     */
+    id: DestinationId;
+    /**
+     * The AWS region being pushed to
+     */
+    awsRegion: string;
+    /**
+     * AWS credentials to be used for connecting to S3
+     * Standard environment variables will be read if these are not provided
+     */
+    awsCredentials?: AwsCredentials;
+    /**
+     * Informs the playlist generation how long segments will be retained for on the remote server
+     * in order to generate an accurate playlist
+     */
+    retentionPeriodSeconds: number;
+}
+
+/**
+ * @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
+ * see: {@link NorskInput.browser}
+ */
+export declare class BrowserInputNode extends SourceMediaNode {
+    /**
+     * @public
+     * Supply new config for an active web browser session
+     * */
+    updateConfig(settings: BrowserInputSettingsUpdate): void;
+    /**
+     * @public
+     * Applies a gradual nudge to the outgoing stream timestamps by the specified number of milliseconds
+     * */
+    nudge(nudge: number): void;
+}
+
+/**
+ * @public
+ * Settings for a Browser Input
+ * see: {@link NorskInput.browser}
+ * */
+export declare interface BrowserInputSettings extends SourceNodeSettings<BrowserInputNode>, StreamStatisticsMixin {
+    /** The url to load in the browser session */
+    url: string;
+    /** This is the resolution of the window opened to render the page
+     * This is therefore also output resolution of the generated video
+     */
+    resolution: {
+        width: number;
+        height: number;
+    };
+    /** The source name to populate the outgoing stream key with */
+    sourceName: string;
+    /** The frame rate at which to generate video from the web page
+     * Note: If the web page is static, this will just mean the initial frame
+     * is duplicated at the required frame rate
+     * */
+    frameRate: FrameRate;
+    /** An optional callback for reacting to events from the embedded browser
+     * At the very least this is useful for logging events (such as a 404)
+     * */
+    onBrowserEvent?: (event: BrowserEvent) => void;
+}
+
+/**
+ * @public
+ * A settings update for a running browser
+ * see: {@link BrowserInputNode.updateConfig}
+ * */
+export declare interface BrowserInputSettingsUpdate {
+    /** Optionally, a new URL to load within the active session */
+    url?: string;
+    /** Optionally, a new resolution to use for outgoing video */
+    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 */
+export declare function clientHostExternal(): string;
+
+/** @public */
+export declare function clientHostInternal(): string;
+
+/** @public */
+export declare function clientPortExternal(): string;
+
+/** @public */
+export declare function clientPortInternal(): string;
+
+/**
+ * @public
+ * see: {@link NorskOutput.cmafAudio}
+ */
+export declare class CmafAudioOutputNode extends CmafNodeWithPlaylist<CmafAudioMessage, "audio", CmafAudioOutputNode> {
+    /** @public */
+    onPlaylistAddition?: (destinationId: DestinationId, pl: HlsPlaylistAdditions) => HlsPlaylist;
+    /**
+     * @public
+     * Updates the credentials for a specific destination within this output by id
+     * see: {@link UpdateCredentials}
+     * see: {@link CmafDestinationSettings}
+     */
+    updateCredentials(settings: UpdateCredentials): void;
+}
+
+/**
+ * @public
+ * Possible destinations for a segmented media stream
+ * - {@link HlsPushDestinationSettings}: Push to a generic HTTP server
+ * - {@link AwsS3PushDestinationSettings}: Push to Amazon S3
+ * - {@link LocalPullDestinationSettings}: Serve directly from the Norsk Web Server
+ * */
+export declare type CmafDestinationSettings = HlsPushDestinationSettings | AwsS3PushDestinationSettings | LocalPullDestinationSettings;
+
+/**
+ * @public
+ * see: {@link NorskOutput.cmafMultiVariant}
+ */
+export declare class CmafMultiVariantOutputNode extends CmafNodeBase<CmafMultiVariantMessage, "video" | "audio" | "subtitle", CmafMultiVariantOutputNode> {
+    /** @public The URL of the file based multi variant playlist */
+    url: string;
+    /**
+     * @public
+     * Updates the credentials for a specific destination within this output by id
+     * see: {@link UpdateCredentials}
+     * see: {@link CmafDestinationSettings}
+     */
+    updateCredentials(settings: UpdateCredentials): void;
+}
+
+/**
+ * @public
+ * Settings for a CMAF Multi Variant Playlist
+ * see {@link NorskOutput.cmafMultiVariant}
+ */
+export declare interface CmafMultiVariantOutputSettings extends SinkNodeSettings<CmafMultiVariantOutputNode> {
+    /**
+     * The name of this multi variant playlist (.m3u8 will be added onto this field to generate a filename)
+     */
+    playlistName: string;
+    /**
+     * A list of destinations {@link CmafDestinationSettings} for this stream to be published to
+     */
+    destinations: CmafDestinationSettings[];
+    /**
+     * Directives to add to the m3u multi variant playlist
+     */
+    m3uAdditions?: string;
+    /**
+     * XML fragment to add to the (top-level) MPD element
+     */
+    mpdAdditions?: string;
+    /**
+     * A callback invoked every time a CMAF multi variant playlist is changed
+     */
+    onPlaylistChange?: (destinationId: DestinationId, playlist: CmafMultiVariantPlaylistData) => CmafMultiVariantPlaylistData;
+}
+
+/** @public */
+export declare interface CmafMultiVariantPlaylistData {
+    hls: string;
+    dash: string;
+}
+
+declare class CmafNodeBase<ClientMessage, Pins extends string, T extends MediaNodeState> extends AutoProcessorMediaNode<Pins> {
+    playlists: HlsPlaylistDestination;
+    destinations: DestinationId[];
+    scheduledTags: ScheduledTag[];
+    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, settings: ProcessorNodeSettings<T> & StreamStatisticsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => Promise<boolean>, onPlaylistAddition: PlaylistOnChangeFn<ClientMessage>, destinations: DestinationId[], subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => void);
+    scheduleTag(tag: MediaPlaylistPart, scheduleAt: Date, destinationId?: DestinationId): ScheduledTag;
+    removeScheduledTag(tagId: number): void;
+}
+
+declare class CmafNodeWithPlaylist<ClientMessage, Pins extends string, T extends MediaNodeState> extends CmafNodeBase<ClientMessage, Pins, T> {
+    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, settings: ProcessorNodeSettings<T> & StreamStatisticsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => Promise<boolean>, playlistPath: PlaylistPath, segmentDuration: number, onPlaylistAddition: PlaylistOnChangeFn<ClientMessage>, destinations: DestinationId[], localDestination?: LocalPullDestinationSettings, maximumPlaylistSegments?: number);
+    /**
+     * @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.cmafMultiVariant} for production.
+     */
+    url(): Promise<string>;
+}
+
+/**
+ * @public
+ * Settings for a CMAF Audio and Video Outputs
+ * see {@link NorskOutput.cmafAudio}, {@link NorskOutput.cmafVideo}
+ */
+export declare interface CmafOutputSettings extends SinkNodeSettings<CmafAudioOutputNode | CmafVideoOutputNode> {
+    /**
+     * The target segment duration in seconds. Norsk will make the largest segments it can
+     * without going over this target
+     */
+    segmentDurationSeconds: number;
+    /**
+     * The target part duration in seconds. Norsk will make the largest parts it can
+     * without going over this target
+     */
+    partDurationSeconds: number;
+    /**
+     * By default, the program date time or event start time will be based on the
+     * timestamp of the first video packet received by Norsk in a stream.
+     *
+     * Assuming minimal latency in Norsk itself, this behaviour is fine - but encodes and composition
+     * or synchronisation with external streams can then result in players requesting segments that don't exist yet
+     *
+     * delayOutputMs can be used to push the timestamp forwards so that players can calculate the edge of the stream accurately.
+     *
+     * This number should match the delayOutputMs of other streams which will be served within the same multi variant playlist
+     */
+    delayOutputMs?: number;
+    /**
+     * Settings for encrypting the content.
+     */
+    encryption?: EncryptionSettings;
+    /**
+     * A list of destinations {@link CmafDestinationSettings} for this stream to be published to
+     */
+    destinations: CmafDestinationSettings[];
+    /**
+     * Directives to add to the m3u media playlist
+     */
+    m3uAdditions?: string;
+    /**
+     * XML fragment to add to the mpd Representation element
+     */
+    mpdAdditions?: string;
+    /**
+     * Audio or video bitrate for the {@link NorskOutput.cmafMultiVariant} playlist
+     */
+    bitrate?: number;
+    /**
+     * The maximum number of segments to display in a single generated playlist
+     */
+    maximumPlaylistSegments?: number;
+}
+
+/**
+ * @public
+ * see: {@link NorskOutput.cmafVideo}
+ */
+export declare class CmafVideoOutputNode extends CmafNodeWithPlaylist<CmafVideoMessage, "video", CmafVideoOutputNode> {
+    /** @public */
+    onPlaylistAddition?: (destinationId: DestinationId, pl: HlsPlaylistAdditions) => HlsPlaylist;
+    /**
+     * @public
+     * Updates the credentials for a specific destination within this output by id
+     * see: {@link UpdateCredentials}
+     * see: {@link CmafDestinationSettings}
+     */
+    updateCredentials(settings: UpdateCredentials): void;
+}
+
+/**
+ * @public
+ * see: {@link NorskOutput.cmafWebVtt}
+ */
+export declare class CmafWebVttOutputNode extends CmafNodeWithPlaylist<CmafWebVttMessage, "subtitle", CmafWebVttOutputNode> {
+    /** @public */
+    onPlaylistAddition?: (destinationId: DestinationId, pl: HlsPlaylistAdditions) => HlsPlaylist;
+    /**
+     * @public
+     * Updates the credentials for a specific destination within this output by id
+     * see: {@link UpdateCredentials}
+     * see: {@link CmafDestinationSettings}
+     */
+    updateCredentials(settings: UpdateCredentials): void;
+}
+
+/**
+ * @public
+ * Settings for a CMAF WebVTT Output
+ * see {@link NorskOutput.cmafWebVtt}
+ */
+export declare interface CmafWebVttOutputSettings extends SinkNodeSettings<CmafWebVttOutputNode> {
+    /**
+     * The target segment duration in seconds, Norsk will split subtitles over multiple segments
+     * in a compliant manner if necessary
+     */
+    segmentDurationSeconds: number;
+    /**
+     * By default, the program date time or event start time will be based on the
+     * timestamp of the first video packet received by Norsk in a stream.
+     *
+     * Assuming minimal latency in Norsk itself, this behaviour is fine - but encodes and composition
+     * or synchronisation with external streams can then result in players requesting segments that don't exist yet
+     *
+     * delayOutputMs can be used to push the timestamp forwards so that players can calculate the edge of the stream accurately.
+     *
+     * This number should match the delayOutputMs of other streams which will be served within the same multi variant playlist
+     */
+    delayOutputMs?: number;
+    /**
+     * A list of destinations {@link CmafDestinationSettings} for this stream to be published to
+     */
+    destinations: CmafDestinationSettings[];
+    /**
+     * A local directory in which to store the segments while they're available
+     */
+    hlsCacheDirectory: string;
+    /**
+     * The maximum number of segments to display in a single generated playlist
+     */
+    maximumPlaylistSegments?: number;
+}
+
+/** @public */
+export declare type ComposeHardwareAcceleration = 
+/**
+* Use the quadra overlay functionality to perform the compose
+*/
+"quadra"
+/**
+* Use an nvidia CUDA kernel to perform the compose
+*/
+| "nvidia";
+
+/** @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
+ * A single layer of a video compose operation
+ * see {@link NorskTransform.videoCompose}
+ * */
+export declare interface ComposePart<Pins> {
+    /** Input pin for this source */
+    pin: Pins;
+    /**
+     * The area within the source picture to include. This may be the full picture
+     * or cropped, and will be rescaled if necessary.
+     * If a referenceResolution is specified, then this is within that coordinate system, otherwise
+     * this is taken to be within the coordinate system of the input image
+     */
+    sourceRect: OffsetRect;
+    /**
+     * The area within the destination picture to place this part of the
+     * composition.
+     * If a referenceResolution is specified, then this is within that coordinate system, otherwise
+     * this is taken to be within the coordinate system of the destination image
+     */
+    destRect: OffsetRect;
+    /**
+     * Z-index to determine ordering by which the sources are overlaid
+     * (higher layers appear on top)
+     */
+    zIndex: number;
+    /**
+     * Opacity multiplier of this overlay (where 0.0 is fully transparent and 1.0
+     * is fully opaque)
+     */
+    opacity: number;
+    /** Optionally identify the part to enable transitions */
+    id?: string;
+    /**
+     * Optionally specify a transition for this part. A transition is applied only
+     * if the part is specified in both the existing and the current/new
+     * configuration, identified by having the same id specified, and a transition
+     * is specified for the new configuration.
+     */
+    transition?: PartTransition;
+    /**
+     * Optionally supply a reference resolution. This allows description of the
+     * composition in a desired coordinate system, e.g. a resolution of 100x100
+     * can be specified to allow the source and destination areas to be described
+     * in percentage terms, or a notional resolution can be used that is
+     * independant of the source resolutions that may be provided.
+     *
+     * If unset, this will be overriden by a global reference resolution if that is present
+     *
+     * This is useful to set if you don't know the input resolution of a part but want to be able to describe
+     * an operation on that part.
+     */
+    referenceResolution?: Resolution;
+}
+
+/** @public */
+export declare interface Context {
+    streams: StreamMetadata[];
+}
+
+/** @public */
+export declare type ContextType = "full" | "singleSource" | "singleProgram" | "singleStream" | "singleRendition";
+
+/** @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 function debugUrlPrefix(): string;
+
+/** @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.
+ * see: {@link NorskInput.deckLink}.
+ */
+export declare class DeckLinkInputNode extends SourceMediaNode {
+    /**
+     * @public
+     * Applies a gradual nudge to the outgoing stream timestamps by the specified number of milliseconds
+     * */
+    nudge(nudge: number): void;
+}
+
+/**
+ * @public
+ * Settings to control SDI capture through a DeckLink card
+ * see: {@link NorskInput.deckLink}
+ */
+export declare interface DeckLinkInputSettings extends InputSettings<DeckLinkInputNode>, StreamStatisticsMixin {
+    /** 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 type DeferredVideoComposeSettings<Pins extends string> = (streams: StreamMetadata[]) => VideoComposeSettings<Pins> | undefined;
+
+/** @public */
+export declare type DestinationId = string;
+
+/**
+ * @public
+ * Drop every N frames from an incoming video stream
+ * */
+export declare interface DropEvery {
+    kind: "every";
+    every: number;
+}
+
+/**
+ * @public
+ * Randomly drop frames on a stream
+ * - 0.0 means don't drop any frames
+ * - 1.0 means drop every single frame
+ * */
+export declare interface DropRandom {
+    kind: "random";
+    percentage: number;
+}
+
+/**
+ * @public
+ * Drop the first N frames from an incoming video stream
+ * */
+export declare interface DropStart {
+    kind: "start";
+    start: number;
+}
+
+/** @public */
+export declare interface EncryptionSettings {
+    /**
+     * The 16-byte key ID used to identify the key, hexadecimal or GUID encoded.
+     */
+    encryptionKeyId: string;
+    /**
+     * The 16-byte key used to encrypt the data, hexadecimal encoded.
+     */
+    encryptionKey: string;
+    /**
+     * The PSSH box(es) to include in the MP4, base64 encoded.
+     * This is typically given by the DRM provider.
+     */
+    encryptionPssh: string;
+    /**
+     * The common encryption scheme used to encrypt data, as per ISO/IEC 23001-7:2016.
+     *
+     * - Default: CBCS encryption scheme (AES-CBC 10% pattern encryption).
+     *   Full-sample encryption for audio tracks, subsample encryption for video
+     *   tracks.
+     *
+     * - CENC encryption scheme (AES-CTR). Full-sample encryption for audio tracks,
+     *   subsample encryption for video tracks.
+     */
+    encryptionScheme?: "cbcs" | "cenc";
+}
+
+/**
+ * @public
+ * see: {@link NorskInput.fileImage}
+ */
+export declare class FileImageInputNode extends SourceMediaNode {
+}
+
+/**
+ * @public
+ * Settings for an image file source
+ * see: {@link NorskInput.fileImage}
+ * */
+export declare interface FileImageInputSettings extends SourceNodeSettings<FileImageInputNode>, StreamStatisticsMixin {
+    /** The source name to set in the stream key of the outgoing stream */
+    sourceName: string;
+    /** the filename to read the image from */
+    fileName: string;
+    /** The file format for the image. Will be inferred from the file name if not specified. */
+    imageFormat?: ImageFormat;
+}
+
+/**
+ * @public
+ * Information about an Mp4 File
+ * */
+export declare interface FileMp4Info {
+    /** The duration of the Mp4 file in millseconds (if known) */
+    durationMs?: number;
+    /** The total length of the mp4 file in bytes, if known */
+    byteLength?: number;
+}
+
+/**
+ * @public
+ * see: {@link NorskInput.fileMp4}
+ */
+export declare class FileMp4InputNode extends SourceMediaNode {
+    /**
+     * @public
+     * Applies a gradual nudge to the outgoing stream timestamps by the specified number of milliseconds
+     * */
+    nudge(nudge: number): void;
+    updateSettings(settings: FileMp4InputSettingsUpdate): void;
+}
+
+/**
+ * @public
+ * Settings for an File Based Mp4 Input
+ * see: {@link NorskInput.fileMp4}
+ */
+export declare interface FileMp4InputSettings extends SourceNodeSettings<FileMp4InputNode>, StreamStatisticsMixin {
+    /** The source name to set in the stream key of the outgoing stream */
+    sourceName: string;
+    /** Path to the MP4 file to read */
+    fileName: string;
+    /** Callback to be notified when the file ends */
+    onEof?: () => void;
+    /** Callback to be notified when the file is initially read */
+    onInfo?: (info: FileMp4Info) => void;
+    /** Whether to loop back to the start of the file after reaching the end (default false) */
+    loop?: boolean;
+}
+
+export declare interface FileMp4InputSettingsUpdate {
+    /** Whether to loop back to the start of the file after reaching the end */
+    loop?: boolean;
+}
+
+/**
+ * @public
+ * see: {@link NorskOutput.fileMp4}
+ */
+export declare class FileMp4OutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+    /**
+     * @public
+     * Writes a non-fragmented MP4 file containing the data received so far to the
+     * supplied filename
+     */
+    writeFile(nonfragmentedFileName: string): void;
+}
+
+/**
+ * @public
+ * Settings to control MP4 file output
+ * see {@link NorskOutput.fileMp4}
+ */
+export declare interface FileMp4OutputSettings extends SinkNodeSettings<FileMp4OutputNode>, StreamStatisticsMixin {
+    /**
+     * 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;
+    /**
+     * Settings for encrypting the audio track.
+     */
+    audioEncryption?: EncryptionSettings;
+    /**
+     * Settings for encrypting the video track.
+     */
+    videoEncryption?: EncryptionSettings;
+    /**
+     * Callback that will be invoked once data stops being received by the node (determined by an empty context)
+     * at which point it will automatically shut down
+     */
+    onStreamEof?: () => void;
+}
+
+/**
+ * @public
+ * see: {@link NorskInput.fileTs}
+ */
+export declare class FileTsInputNode extends TsCommonInputNode<FileTsInputMessage, FileTsInputNode> {
+    updateSettings(settings: FileTsInputSettingsUpdate): void;
+}
+
+/** @public */
+export declare interface FileTsInputSettings extends LocalFileInputSettings, StreamStatisticsMixin {
+    /** Whether to loop back to the start of the file after reaching the end */
+    loop?: boolean;
+}
+
+/** @public */
+export declare interface FileTsInputSettingsUpdate {
+    /** Whether to loop back to the start of the file after reaching the end */
+    loop?: boolean;
+}
+
+/**
+ * @public
+ * see: {@link NorskOutput.fileTs}
+ */
+export declare class FileTsOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+}
+
+/**
+ * @public
+ * The settings for an output Transport Stream written to file
+ * see: {@link NorskOutput.fileTs}
+ */
+export declare interface FileTsOutputSettings extends SinkNodeSettings<FileTsOutputNode>, StreamStatisticsMixin {
+    /** The file to write - this will be truncated if it already exist */
+    fileName: string;
+    /** A/V delay in milliseconds - to allow inclusion of subtitles, metadata and other ancillary data. May be set to 0 if these are not present to reduce latency */
+    avDelayMs?: number;
+}
+
+/**
+ * @public
+ * see: {@link NorskInput.fileWebVtt}
+ */
+export declare class FileWebVttInputNode extends SourceMediaNode {
+}
+
+/** @public */
+export declare interface FrameRate {
+    frames: number;
+    seconds: number;
+}
+
+/** @public */
+export declare type FrameStoreCut = {
+    startDateTime: Date;
+    durationMs: number;
+    sessionNum?: number;
+};
+
+/** @public */
+export declare type FrameStoreCutRequest = {
+    fileFormat: "mp4";
+    id: string;
+    streamSelection: FrameStoreStreamSelection;
+    cuts: FrameStoreCut[];
+    trimPartialSegments: boolean;
+    fileName: string;
+    progressCb: (progress: number) => void;
+    completeCb: (size: bigint) => void;
+};
+
+/** @public */
+export declare type FrameStoreExpireBySize = {
+    expire: "bySize";
+    size: number;
+};
+
+/** @public */
+export declare type FrameStoreExpireByTime = {
+    expire: "byTime";
+    durationS: number;
+};
+
+/** @public */
+export declare type FrameStoreExpiry = FrameStoreExpireBySize | FrameStoreExpireByTime;
+
+/**
+ * @public
+ * see: {@link NorskInput.frameStorePlayer}
+ */
+export declare class FrameStorePlayerNode extends SourceMediaNode {
+}
+
+/**
+ * @public
+ * Settings for Frame Store playback
+ * see: {@link NorskInput.frameStorePlayer}
+ */
+export declare interface FrameStorePlayerSettings extends InputSettings<FrameStorePlayerNode>, StreamStatisticsMixin {
+    /**
+     * Required: Name of the frame store instance.
+     */
+    name: string;
+    /**
+     * Required: The streams you want to playback from the frame store
+     */
+    streamSelection: FrameStoreStreamSelection;
+    /**
+     * Required: The start times and durations of the playback
+     */
+    cuts: FrameStoreCut[];
+    /**
+     * Required: If a start time or end time falls mid-gop, should the gop be trimmed to be frame accurate?
+     */
+    trimPartialSegments: boolean;
+    /** Callback to be notified when playback ends */
+    onEof?: () => void;
+}
+
+/**
+ * @public
+ * see: {@link NorskOutput.frameStoreRecording}
+ */
+export declare class FrameStoreRecorderNode extends AutoSinkMediaNode<"audio" | "video"> {
+    makeCut(request: FrameStoreCutRequest): void;
+}
+
+/**
+ * @public
+ * Settings to configure a frame store recorder
+ * see {@link NorskOutput.frameStoreRecorder}
+ */
+export declare interface FrameStoreRecorderSettings extends SinkNodeSettings<FrameStoreRecorderNode>, StreamStatisticsMixin {
+    /**
+     * Required: Name of this frame store instance.
+     */
+    name: string;
+    /**
+     * Required: Path for the frame store database.
+     */
+    path: string;
+    /**
+     * Required: Duration of the frame store chunk files
+     */
+    chunkFileDurationSeconds: number;
+    /**
+     * Optional: Expiry settings - if not supplied, then data will *not* get expired so on long-running events you may exhaust available disk space
+     */
+    expiry?: FrameStoreExpiry;
+}
+
+/** @public */
+export declare type FrameStoreStreamSelection = "all" | StreamKey[];
+
+export declare function fromVancPayloadFormat(format: VancPayloadFormat_2): VancPayloadFormat;
+
+/**
+ * @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
+ *
+ */
+/**
+ * @public
+ */
+export declare interface HardwareInfo {
+    cpuTopology: CpuTopology;
+    systemMemory: number;
+    deckLinkCards: DeckLinkCard[];
+}
+
+/** @public */
+export declare type HlsPlaylist = {
+    hlsFilePartPlaylist: MediaPlaylistPart[];
+    hlsByteRangePlaylist: MediaPlaylistPart[];
+    hlsStandardPlaylist: MediaPlaylistPart[];
+    programDateTime?: Date;
+};
+
+/** @public */
+export declare type HlsPlaylistAdditions = HlsPlaylist;
+
+declare type HlsPlaylistDestination = {
+    [destination: DestinationId]: HlsPlaylist;
+};
+
+/**
+ * @public
+ * Configuration for pushing a segmented media stream directly to a generic http server
+ * */
+export declare interface HlsPushDestinationSettings {
+    type: "generic";
+    /** The hostname of the web server being pushed to.
+     * This will be used to re-resolve the IP address on failures
+     * */
+    host: string;
+    /** the port of the web server being pushed to. */
+    port: number;
+    /** the path under which segments and playlists will be pushed to */
+    pathPrefix: string;
+    /**
+     * Optionally supply a string that will be inserted into the path structure for segments published in this stream
+     *
+     * This is useful for stream restarts or republishing when duplicate segment IDs would be generated causing problems with
+     * cacheing directives
+     */
+    sessionId?: string;
+    /**
+     * A unique identifier for this destination
+     *
+     * This can be used for supplying updates to configuration to this destination specifically
+     * see: {@link UpdateCredentials}
+     */
+    id: DestinationId;
+    /**
+     * Informs the playlist generation how long segments will be retained for on the remote server
+     * in order to generate an accurate playlist
+     */
+    retentionPeriodSeconds: number;
+}
+
+/** @public */
+export declare interface HlsTag {
+    tag: string;
+}
+
+/**
+ * @public
+ * see: {@link NorskOutput.hlsTsAudio}
+ */
+export declare class HlsTsAudioOutputNode extends CmafNodeWithPlaylist<HlsTsAudioMessage, "audio", HlsTsAudioOutputNode> {
+    /** @public */
+    onPlaylistAddition?: (destinationId: DestinationId, pl: TsPlaylistAdditions) => TsPlaylist;
+    get playlist(): HlsTsPlaylistDestination;
+    /**
+     * @public
+     * Updates the credentials for a specific destination within this output by id
+     * see: {@link UpdateCredentials}
+     * see: {@link CmafDestinationSettings}
+     */
+    updateCredentials(settings: UpdateCredentials): void;
+}
+
+/**
+ * @public
+ * Settings for a HLS TS Audio Output
+ * see {@link NorskOutput.hlsTsAudio}
+ */
+export declare interface HlsTsAudioOutputSettings extends SinkNodeSettings<HlsTsAudioOutputNode> {
+    /**
+     * The target segment duration in seconds. Norsk will make the largest segments it can
+     * without going over this target using the durations of the individual audio frames
+     */
+    segmentDurationSeconds: number;
+    /**
+     * By default, the program date time or event start time will be based on the
+     * timestamp of the first video packet received by Norsk in a stream.
+     *
+     * Assuming minimal latency in Norsk itself, this behaviour is fine - but encodes and composition
+     * or synchronisation with external streams can then result in players requesting segments that don't exist yet
+     *
+     * delayOutputMs can be used to push the timestamp forwards so that players can calculate the edge of the stream accurately.
+     *
+     * This number should match the delayOutputMs of other streams which will be served within the same multi variant playlist
+     */
+    delayOutputMs?: number;
+    /**
+     * A list of destinations {@link CmafDestinationSettings} for this stream to be published to
+     */
+    destinations: CmafDestinationSettings[];
+    /**
+     * Directives to add to the m3u media playlist
+     */
+    m3uAdditions?: string;
+    /**
+     * XML fragment to add to the mpd Representation element
+     */
+    mpdAdditions?: string;
+    /**
+     * Audio bitrate for the {@link NorskOutput.hlsTsMultiVariant} playlist
+     */
+    bitrate?: number;
+    /**
+     * The maximum number of segments to display in a single generated playlist
+     */
+    maximumPlaylistSegments?: number;
+}
+
+/**
+ * @public
+ * see: {@link NorskOutput.hlsTsCombinedPush}
+ */
+export declare class HlsTsCombinedPushOutputNode extends CmafNodeWithPlaylist<HlsTsCombinedPushMessage, "audio" | "video", HlsTsCombinedPushOutputNode> {
+}
+
+/**
+ * @public
+ * Settings for a HLS Transport Stream Combined Push Output
+ * see {@link NorskOutput.hlsTsCombinedPush}
+ */
+export declare interface HlsTsCombinedPushOutputSettings extends SinkNodeSettings<HlsTsCombinedPushOutputNode> {
+    /**
+     * The target segment duration in seconds. Norsk will use the framerate of the video stream in order
+     * to produce compliant segments that are less than or equal to this in duration, with audio packaged alongside
+     * using timestamps to line them up
+     */
+    segmentDurationSeconds: number;
+    /**
+     * By default, the program date time or event start time will be based on the
+     * timestamp of the first video packet received by Norsk in a stream.
+     *
+     * Assuming minimal latency in Norsk itself, this behaviour is fine - but encodes and composition
+     * or synchronisation with external streams can then result in players requesting segments that don't exist yet
+     *
+     * delayOutputMs can be used to push the timestamp forwards so that players can calculate the edge of the stream accurately.
+     *
+     * This number should match the delayOutputMs of other streams which will be served within the same multi variant playlist
+     */
+    delayOutputMs?: number;
+    /**
+     * The destination {@link CmafDestinationSettings} for this stream to be published to
+     */
+    destination: CmafDestinationSettings;
+    /**
+     * The name of this media playlist (.m3u8 will be added onto this field to generate a filename)
+     */
+    playlistName: string;
+    /**
+     * Directives to add to the m3u media playlists
+     */
+    m3uAdditions?: string;
+}
+
+/**
+ * @public
+ * see: {@link NorskOutput.hlsTsMultiVariant}
+ */
+export declare class HlsTsMultiVariantOutputNode extends CmafNodeBase<HlsTsMultiVariantMessage, "video" | "audio" | "subtitle", HlsTsMultiVariantOutputNode> {
+    /** @public The URL of the file based multi variant playlist */
+    url: string;
+    /**
+     * @public
+     * Updates the credentials for a specific destination within this output by id
+     * see: {@link UpdateCredentials}
+     * see: {@link CmafDestinationSettings}
+     */
+    updateCredentials(settings: UpdateCredentials): void;
+}
+
+/**
+ * @public
+ * Settings for a Hls Ts Multivariant Playlist
+ * see {@link NorskOutput.hlsTsMultiVariant}
+ */
+export declare interface HlsTsMultiVariantOutputSettings extends SinkNodeSettings<HlsTsMultiVariantOutputNode> {
+    /**
+     * The name of this multi variant playlist (.m3u8 will be added onto this field to generate a filename)
+     */
+    playlistName: string;
+    /**
+     * A list of destinations {@link CmafDestinationSettings} for this stream to be published to
+     */
+    destinations: CmafDestinationSettings[];
+    /**
+     * Directives to add to the m3u multi variant playlist
+     */
+    m3uAdditions?: string;
+    /**
+     * A callback invoked every time a TS multi variant playlist is changed
+     */
+    onPlaylistChange?: (destinationId: DestinationId, playlist: string) => string;
+}
+
+declare type HlsTsPlaylistDestination = {
+    [destination: DestinationId]: MediaPlaylistPart[];
+};
+
+/**
+ * @public
+ * see: {@link NorskOutput.hlsTsVideo}
+ */
+export declare class HlsTsVideoOutputNode extends CmafNodeWithPlaylist<HlsTsVideoMessage, "video", HlsTsVideoOutputNode> {
+    /** @public */
+    onPlaylistAddition?: (destinationId: DestinationId, pl: TsPlaylistAdditions) => TsPlaylist;
+    get playlist(): HlsTsPlaylistDestination;
+    /**
+     * @public
+     * Updates the credentials for a specific destination within this output by id
+     * see: {@link UpdateCredentials}
+     * see: {@link CmafDestinationSettings}
+     */
+    updateCredentials(settings: UpdateCredentials): void;
+}
+
+/**
+ * @public
+ * Settings for a HLS TS Video Output
+ * see {@link NorskOutput.hlsTsVideo}
+ */
+export declare interface HlsTsVideoOutputSettings extends SinkNodeSettings<HlsTsVideoOutputNode> {
+    /**
+     * The target segment duration in seconds. Norsk will use the framerate of the stream in order
+     * to produce compliant segments that are less than or equal to this in duration
+     */
+    segmentDurationSeconds: number;
+    /**
+     * By default, the program date time or event start time will be based on the
+     * timestamp of the first video packet received by Norsk in a stream.
+     *
+     * Assuming minimal latency in Norsk itself, this behaviour is fine - but encodes and composition
+     * or synchronisation with external streams can then result in players requesting segments that don't exist yet
+     *
+     * delayOutputMs can be used to push the timestamp forwards so that players can calculate the edge of the stream accurately.
+     *
+     * This number should match the delayOutputMs of other streams which will be served within the same multi variant playlist
+     */
+    delayOutputMs?: number;
+    /**
+     * A list of destinations {@link CmafDestinationSettings} for this stream to be published to
+     */
+    destinations: CmafDestinationSettings[];
+    /**
+     * Directives to add to the m3u media playlist
+     */
+    m3uAdditions?: string;
+    /**
+     * XML fragment to add to the mpd Representation element
+     */
+    mpdAdditions?: string;
+    /**
+     * Video bitrate for the {@link NorskOutput.hlsTsMultiVariant} playlist
+     */
+    bitrate?: number;
+    /**
+     * The maximum number of segments to display in a single generated playlist
+     */
+    maximumPlaylistSegments?: number;
+}
+
+/** @public */
+export declare type IceServerSettings = {
+    urls: string[];
+    username?: string;
+    credential?: string;
+};
+
+/** @public */
+export declare type ImageFormat = "png" | "jpeg" | "gif" | "webp" | "pnm" | "tiff" | "tga" | "dds" | "bmp" | "ico" | "hdr" | "openexr" | "farbfeld" | "avif";
+
+/**
+ * @public
+ * Base settings for most input nodes
+ * */
+export declare interface InputSettings<T extends MediaNodeState> extends SourceNodeSettings<T> {
+    /** The source name to set on the stream key on the outgoing stream from this node */
+    sourceName: string;
+}
+
+/** @public */
+export declare type InsertComponent = {
+    components: Scte35InsertCommandComponent[];
+};
+
+/** @public */
+export declare type InsertProgram = {
+    spliceTime?: Scte35SpliceTime;
+};
+
+/** @public A time interval measured as ticks / (ticks per second) */
+export declare interface Interval {
+    n: number;
+    d: number;
+}
+
+/** @public */
+export declare interface IntervalTimestamp {
+    n: number;
+    d: number;
+}
+
+/** @public */
+export declare function isAdMarker(seg: MediaPlaylistPart): seg is AdMarker;
+
+/** @public */
+export declare function isHlsTag(seg: MediaPlaylistPart): seg is HlsTag;
+
+/** @public */
+export declare function isMediaSegment(seg: MediaPlaylistPart): seg is MediaSegment;
+
+/** @public */
+export declare function isProgramDateTime(seg: MediaPlaylistPart): seg is ProgramDateTime;
+
+/** @public */
+export declare function isScheduledTag(seg: MediaPlaylistPart): seg is ScheduledTag;
+
+/**
+ * @public
+ * see: {@link NorskTransform.jitterBuffer}
+ */
+export declare class JitterBufferNode extends AutoProcessorMediaNode<"audio" | "video" | "subtitle"> {
+}
+
+/**
+ * @public
+ * Settings for a Jitter Buffer
+ * see: {@link NorskTransform.jitterBuffer}
+ * */
+export declare interface JitterBufferSettings extends ProcessorNodeSettings<JitterBufferNode> {
+    /** Buffer delay in milliseconds */
+    delayMs: number;
+}
+
+/**
+ * @public
+ * The standard settings for any node reading from a file
+ * */
+export declare interface LocalFileInputSettings extends InputSettings<SourceMediaNode> {
+    /** The file to be read from */
+    fileName: string;
+    /** An optional callback that will be invoked when file end is reached */
+    onEof?: () => void;
+}
+
+/**
+ * @public
+ * Configuration for the serving of segments and playlists directly from the Norsk Web Server
+ * Note: While this is both useful for local testing and for sitting behind a reverse caching proxy / CDN
+ * it is not expected that Norsk serve as the edge server in most scenarios
+ * */
+export declare interface LocalPullDestinationSettings {
+    type: "local";
+    /**
+     * A unique identifier for this destination
+     */
+    id: DestinationId;
+    /**
+     * Optionally supply a string that will be inserted into the path structure for segments published in this stream
+     *
+     * This is useful for stream restarts or republishing when duplicate segment IDs would be generated causing problems with
+     * cacheing directives
+     */
+    sessionId?: string;
+    /**
+     * Informs the playlist generation how long segments will be retained for
+     * and informs the local web server how long to retain those segments
+     */
+    retentionPeriodSeconds: number;
+}
+
+/** @public */
+export declare type Log = {
+    level: "emergency" | "alert" | "critical" | "error" | "warning" | "notice" | "info" | "debug";
+    timestamp: Date;
+    message: string;
+    metadata: string;
+};
+
+/**
+ * @public
+ * Settings for a H264 Encode using Netint Logan hardware
+ * A detailed description of these params can be found
+ * on the Netint Logan Encoder Documentation
+ *
+ * These fields have deliberately been written to maintain the same semantics as the
+ * Logan documentation where possible.
+ *
+ * If left undefined, all will default to Logan's own defaults
+ * */
+export declare interface LoganH264 {
+    type: "logan-h264";
+    /** This (for convenience) takes the xcoder string that Logan's
+     * Ffmpeg integration accepts, this is to aid developers in getting up and running
+     * quickly and will override any values set manually in the rest of this interface.
+     *
+     * It is expected that developers will choose to use the typed fields for most things instead
+     * when moving to production, as they offer a degree of validation and type safety
+     * */
+    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?: LoganH264Profile;
+    level?: LoganH264Level;
+}
+
+/** @public */
+export declare type LoganH264Level = 1 | 2 | 2.1 | 3 | 3.1 | 4 | 4.1 | 5 | 5.1 | 5.2 | 6 | 6.1 | 6.2;
+
+/** @public */
+export declare type LoganH264Profile = "baseline" | "main" | "extended" | "high" | "high10";
+
+/**
+ * @public
+ * Settings for a HEVC Encode using Netint Logan hardware
+ * A detailed description of these params can be found
+ * on the Netint Logan Encoder Documentation
+ *
+ * These fields have deliberately been written to maintain the same semantics as the
+ * Logan documentation where possible.
+ *
+ * If left undefined, all will default to Logan's own defaults
+ * */
+export declare interface LoganHevc {
+    type: "logan-hevc";
+    /** This (for convenience) takes the xcoder string that Logan's
+     * Ffmpeg integration accepts, this is to aid developers in getting up and running
+     * quickly and will override any values set manually in the rest of this interface.
+     *
+     * It is expected that developers will choose to use the typed fields for most things instead
+     * when moving to production, as they offer a degree of validation and type safety
+     * */
+    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?: LoganHevcProfile;
+    level?: LoganHevcLevel;
+    tier?: LoganHevcTier;
+    lossless?: boolean;
+    hrdEnable?: boolean;
+    dolbyVisionProfile?: number;
+}
+
+/** @public */
+export declare type LoganHevcLevel = 1 | 2 | 2.1 | 3 | 3.1 | 4 | 4.1 | 5 | 5.1 | 5.2 | 6 | 6.1 | 6.2;
+
+/** @public */
+export declare type LoganHevcProfile = "main" | "main10";
+
+/** @public */
+export declare type LoganHevcTier = "main" | "high";
+
+/** @public */
+export declare type LogicalCpuId = number;
+
+/** @public */
+export declare type MediaNodeId = string;
+
+/** @public */
+export declare class MediaNodeState {
+    id: MediaNodeId | undefined;
+    closeAwait?: () => void;
+    closed: boolean;
+    constructor(client: MediaClient);
+    close(): Promise<void>;
+}
+
+/** @public */
+export declare type MediaPlaylistPart = MediaSegment | AdMarker | HlsTag | ProgramDateTime | ScheduledTag;
+
+/** @public */
+export declare interface MediaSegment {
+    uri: string;
+    duration: number;
+    title: string;
+    number?: number;
+}
+
+export declare class MetadataCombineMode extends AutoProcessorMediaNode<"ancillary"> {
+}
+
+export declare interface MetadataCombineSettings extends ProcessorNodeSettings<MetadataCombineMode> {
+    outputStreamKey: StreamKey;
+    maxSyncDelta?: number;
+}
+
+/**
+ * @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, pssh?: string | undefined): EncryptionSettings | undefined;
+
+/** @public */
+export declare function mkSine(freq: number): Wave;
+
+/**
+ * @public
+ * see: {@link NorskOutput.moqEgest}
+ */
+export declare class MoqEgestNode extends AutoSinkMediaNode<"audio" | "video"> {
+}
+
+/**
+ * @public
+ * Settings to configure a Moq Egest
+ * see {@link NorskOutput.moqEgest}
+ */
+export declare interface MoqEgestSettings extends SinkNodeSettings<MoqEgestNode>, StreamStatisticsMixin {
+}
+
+/** @public */
+export declare interface MultiStreamStatistics {
+    allStreams: SingleStreamStatistics[];
+    sampleSizeSeconds: number;
+    /**
+     * Either `"default"`, if there is only one direction, or `"input"`/`"output"`
+     * (for duplex nodes, where there are two directions)
+     */
+    label: string;
+    total: StreamStatistics;
+    audio: StreamStatistics;
+    video: StreamStatistics;
+}
+
+/** @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 with any errors from the Node.
+     *
+     * This includes both errors which will cause the node to exit, and those that do not
+     * but may e.g. indicate a connection has failed.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Called when the Node closes.
+     *
+     * This may be by request, because the node naturally exits or an error has occurred. See `onError`
+     * to be notified of errors which may lead to the node closing.
+     */
+    onClose?: (() => Promise<void>) | (() => 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 NorskDebug} interface
+     */
+    debug: NorskDebug;
+    /**
+     * Implements the {@link NorskSystem} interface
+     */
+    system: NorskSystem;
+    /**
+     * Norsk Runtime version information
+     */
+    version: Version;
+    close(): Promise<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
+     */
+    streamSwitchHard<Pins extends string>(settings: StreamSwitchHardSettings<Pins>): Promise<StreamSwitchHardNode<Pins>>;
+    /**
+     * Switch between multiple input sources without interruption, via a transition.
+     * @param settings - Options for the switcher
+     */
+    streamSwitchSmooth<Pins extends string>(settings: StreamSwitchSmoothSettings<Pins>): Promise<StreamSwitchSmoothNode<Pins>>;
+    /**
+     * Record statistical information about media streams, including bitrate,
+     * frame rate, and number of keyframes, measured over some configurable
+     * sampling windows.
+     *
+     * Corresponding settings are found on many input and output nodes.
+     * @param settings - Callback and sampling intervals
+     */
+    streamStatistics(settings: StreamStatisticsSettings): Promise<StreamStatisticsNode>;
+    /**
+     * Monitor the volume of an audio stream
+     * @param settings - Callback and options for the level data
+     */
+    audioMeasureLevels(settings: AudioMeasureLevelsSettings): Promise<AudioMeasureLevelsNode>;
+}
+
+/**
+ * @public
+ * Methods that allow you to inspect a system (typically during development)
+ */
+export declare interface NorskDebug {
+    /** Creates a node to intercept all the timestamps of any subscribed stream
+     * @param settings - Configuration for the report node
+     */
+    streamTimestampReport(settings: StreamTimestampReportSettings): Promise<StreamTimestampReportNode>;
+}
+
+/**
+ * @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.
+     * (Available from {@link WebRTCBrowserNode.playerUrl}
+     * 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
+     */
+    webRtcBrowser(settings: WebRTCBrowserSettings): Promise<WebRTCBrowserNode>;
+}
+
+/** @public */
+export declare function norskHost(): string;
+
+/**
+ * @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>;
+    /**
+     * Read from a Transport Stream file with realtime playback.
+     * @param settings - Configuration for the file input
+     */
+    fileTs(settings: FileTsInputSettings): Promise<FileTsInputNode>;
+    /**
+     * Stream from a SRT source
+     * @param settings - Configuration for the SRT input
+     */
+    srt(settings: SrtInputSettings): Promise<SrtInputNode>;
+    /**
+     * Receive media via WebRTC via the WHIP standard.
+     *
+     * Here Norsk acts as the Media Server receiving from a remote WHIP client, to act as the
+     * WHIP client sending to a remote media server see {@link NorskOutput.whip}. For a duplex
+     * connection to a browser peer see {@link NorskDuplex.webRtcBrowser}.
+     *
+     * @param settings - Configuration for the WHIP input
+     */
+    whip(settings: WhipInputSettings): Promise<WhipInputNode>;
+    /**
+     * Read from a Transport Stream on the network
+     * This can be multicast/unicast or broadcast
+     * @param settings - Configuration for the UDP input
+     */
+    udpTs(settings: UdpTsInputSettings): Promise<UdpTsInputNode>;
+    fileWebVtt(settings: LocalFileInputSettings): Promise<FileWebVttInputNode>;
+    /**
+     * Read an image from a file. Various image formats are supported, see the
+     * documentation for {@link FileImageInputSettings} for more details.
+     * @param settings - Configuration for the file input
+     *
+     * The image will then be provided into Norsk as a video at 25fps for use
+     * in other operations
+     */
+    fileImage(settings: FileImageInputSettings): Promise<FileImageInputNode>;
+    /**
+     * 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
+     */
+    fileMp4(settings: FileMp4InputSettings): Promise<FileMp4InputNode>;
+    /**
+     * Stream from a remote RTP source
+     *
+     * Note that MPEG-TS sources encapsulated in RTP should use the {@link NorskInput.udpTs} input with appropriate config.
+     * @param settings - Configuration for the RTP input
+     */
+    rtp(settings: RtpInputSettings): Promise<RtpInputNode>;
+    /**
+     * Generate a test video card with a configurable pattern.
+     * @param settings - Configuration for the video test card
+     */
+    videoTestCard(settings: VideoTestcardGeneratorSettings): Promise<VideoTestcardGeneratorNode>;
+    /**
+     * Generate a test audio signal with a configurable waveform.
+     * @param settings - Configuration for the audio signal
+     */
+    audioSignal(settings: AudioSignalGeneratorSettings): Promise<AudioSignalGeneratorNode>;
+    /**
+     * Generates a video source by 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>;
+    /**
+     * Playback from an existing Frame Store recording
+     */
+    frameStorePlayer(settings: FrameStorePlayerSettings): Promise<FrameStorePlayerNode>;
+}
+
+/**
+ * @public
+ * Methods that allow you to egest media from your application
+ */
+export declare interface NorskOutput {
+    /**
+     * Produces video segments with the supplied settings for use in
+     * HLS or DASH manifests.
+     *
+     * These can optionally be served the Norsk web server or be pushed
+     * to other locations - see {@link CmafDestinationSettings}
+     *
+     * @param settings - Configuration for the CMAF Video Stream
+     */
+    cmafVideo(settings: CmafOutputSettings): Promise<CmafVideoOutputNode>;
+    /**
+     * Produces audio segments with the supplied settings for use in
+     * HLS or DASH manifests.
+     *
+     * These can optionally be served via the Norsk web server or be pushed
+     * to other locations - see {@link CmafDestinationSettings}
+     *
+     * @param settings - Configuration for the CMAF Audio Stream
+     */
+    cmafAudio(settings: CmafOutputSettings): Promise<CmafAudioOutputNode>;
+    /**
+     * Produces WebVTT segments with the supplied settings for use in
+     * HLS or DASH manifests. These are served via the Norsk web server
+     *
+     * @param settings - Configuration for the CMAF WebVTT Stream
+     */
+    cmafWebVtt(settings: CmafWebVttOutputSettings): Promise<CmafWebVttOutputNode>;
+    /**
+     * Produces a multi variant (used to be known as master) hls and/or dash manifest for a collection of media streams
+     *
+     * This can optionally be served via the Norsk web server or be pushed
+     * to other locations - see {@link CmafDestinationSettings}
+     *
+     * @param settings - Configuration for the CMAF Multi Variant Manifest
+     */
+    cmafMultiVariant(settings: CmafMultiVariantOutputSettings): Promise<CmafMultiVariantOutputNode>;
+    /**
+     * Produces Transport Stream video segments with the supplied settings for use in
+     * HLS manifests and builds a playlist served locally from the Norsk Web Server
+     * or from other locations - see {@link CmafDestinationSettings}
+     *
+     * @param settings - Configuration for the HLS TS Stream
+     */
+    hlsTsVideo(settings: HlsTsVideoOutputSettings): Promise<HlsTsVideoOutputNode>;
+    /**
+     * Produces Transport Stream audio segments with the supplied settings for use in
+     * HLS manifests and builds a playlist served locally from the Norsk Web Server
+     *  or from other locations - see {@link CmafDestinationSettings}
+     *
+     * @param settings - Configuration for the HLS TS Stream
+     */
+    hlsTsAudio(settings: HlsTsAudioOutputSettings): Promise<HlsTsAudioOutputNode>;
+    /**
+     * Produces Transport Stream segments containing both video and audio with the supplied settings for use in
+     * HLS manifests and pushes them to the configured location (see {@link CmafDestinationSettings})
+     *
+     * @param settings - Configuration for the HLS TS Stream
+     */
+    hlsTsCombinedPush(settings: HlsTsCombinedPushOutputSettings): Promise<HlsTsCombinedPushOutputNode>;
+    /**
+     * Produces a multi variant HLS TS manifest for a collection of media streams
+     *
+     * This can optionally be served via the Norsk web server or be pushed
+     * to other locations - see {@link CmafDestinationSettings}
+     *
+     * @param settings - Configuration for the Hls Ts Multivariant Playlist
+     */
+    hlsTsMultiVariant(settings: HlsTsMultiVariantOutputSettings): Promise<HlsTsMultiVariantOutputNode>;
+    /**
+     * Produces a Transport Stream optionally containing both video and audio
+     * and sends it out over UDP
+     *
+     * @param settings - Configuration for the TS Stream
+     */
+    udpTs(settings: UdpTsOutputSettings): Promise<UdpTsOutputNode>;
+    /**
+     * Produces a Transport Stream, and allows Norsk to either connect to an existing
+     * SRT server or act as an SRT server itself
+     *
+     * @param settings - Configuration for the SRT Stream
+     */
+    srt(settings: SrtOutputSettings): Promise<SrtOutputNode>;
+    /**
+     * Connects and sends media to a remote server via WebRTC using the WHIP standard.
+     *
+     * Here Norsk acts as the WHIP client sending to a remote Media Server; to
+     * have Norsk act as the Media Server ingesting from some other WHIP client, see
+     * {@link NorskInput.whip}
+     *
+     * @param settings - Configuration for the WebRTC Stream
+     */
+    whip(settings: WhipOutputSettings): Promise<WhipOutputNode>;
+    /**
+     * Hosts media for clients connecting via WebRTC using the WHEP standard.
+     *
+     * To send media to a remote Media Server via WebRTC see {@link NorskOutput.whip}.
+     * See also {@link NorskInput.whip}, {@link NorskDuplex.webRtcBrowser}.
+     *
+     * @param settings - Configuration for the WebRTC Stream
+     */
+    whep(settings: WhepOutputSettings): Promise<WhepOutputNode>;
+    /**
+     * Connects and sends media to a remote RTMP server
+     *
+     * @param settings - Configuration for the WebRTC Stream
+     */
+    rtmp(settings: RtmpOutputSettings): Promise<RtmpOutputNode>;
+    /**
+     * Stream to a Transport Stream file.
+     *
+     * @param settings - Configuration for the Transport Stream output
+     */
+    fileTs(settings: FileTsOutputSettings): Promise<FileTsOutputNode>;
+    /**
+     * 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 FileMp4OutputNode.close} and will be fully written by the time
+     * {@link NodeSettings.onClose} 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 FileMp4OutputNode.writeFile}, which uses the frame data store if
+     * {@link FileMp4OutputSettings.nonfragmentedFileName} was given or reads
+     * back the fragmented mp4 if there is no non-fragmented file.
+     *
+     * @param settings - Configuration for the MP4 output.
+     */
+    fileMp4(settings: FileMp4OutputSettings): Promise<FileMp4OutputNode>;
+    /**
+     * Create a frame store recording
+     *
+     * @param settings - Configuration for the frame store recorder
+     */
+    frameStoreRecording(settings: FrameStoreRecorderSettings): Promise<FrameStoreRecorderNode>;
+    /**
+     * Create a Moq Egest
+     *
+     * @param settings - Configuration for the egest
+     */
+    moqEgest(settings: MoqEgestSettings): Promise<MoqEgestNode>;
+}
+
+/** @public */
+export declare function norskPort(): string;
+
+/** @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 it logs and nothing else */
+    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
+     * using either software or appropriate hardware if available
+     * @param settings - Encode ladder settings
+     */
+    videoEncode(settings: VideoEncodeSettings): Promise<VideoEncodeNode>;
+    /**
+     * Transform a single video stream (rescale, frame rate, etc)
+     * @param settings - Transform settings
+     */
+    videoTransform(settings: VideoTransformSettings): Promise<VideoTransformNode>;
+    /**
+     * Interferes with a stream by dropping frames
+     * Why would you want this? Stick one of these after a decoder and before
+     * anything else in order to simulate what the world is going to look like if you
+     * have network problems (packet drops for example) in your ingest
+     *
+     * *Just don't forget to remove it again when you've finished testing!*
+     * @param settings - Chaos monkey settings
+     */
+    streamChaosMonkey(settings: StreamChaosMonkeySettings): Promise<StreamChaosMonkeyNode>;
+    /**
+     * Compose multiple video streams together into a single output
+     * @param settings - Composition settings
+     */
+    videoCompose<Pins extends string>(settings: VideoComposeSettings<Pins> | DeferredVideoComposeSettings<Pins>): Promise<VideoComposeNode<Pins>>;
+    /**
+     * Create a Media Node performing transcription into subtitles using the
+     * Amazon Transcribe AWS service.
+     * @param settings - Settings and credentials for AWS transcribe
+     */
+    audioTranscribeAws(settings: AudioTranscribeAwsSettings): Promise<AudioTranscribeAwsNode>;
+    /**
+     * Create a Media Node performing transcription into subtitles using the
+     * Azure Speech service.
+     * @param settings - Settings and credentials for Azure transcribe
+     */
+    audioTranscribeAzure(settings: AudioTranscribeAzureSettings): Promise<AudioTranscribeAzureNode>;
+    /**
+     * Create a Media Node performing transcription into subtitles using the
+     * Whisper speech recognition model.
+     * @param settings - Settings and credentials for Whisper transcribe
+     */
+    audioTranscribeWhisper(settings: AudioTranscribeWhisperSettings): Promise<AudioTranscribeWhisperNode>;
+    /**
+     * 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
+     */
+    audioMix<Pins extends string>(settings: AudioMixSettings<Pins>): Promise<AudioMixNode<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
+     */
+    audioMixMatrix(settings: AudioMixMatrixSettings): Promise<AudioMixMatrixNode>;
+    /**
+     * Apply gain to an audio stream
+     * @param settings - Settings for the gain node
+     */
+    audioGain(settings: AudioGainSettings): Promise<AudioGainNode>;
+    /**
+     * Aggregate many single-channel audio streams into a stream with the
+     * specified channel layout. The streams must all have the same sample format
+     * and sample rate. The order of the streams provided for the channels is
+     * important.
+     * @param settings - Settings for the builder, including the channel layout
+     * and stream keys specifying the sources for each channel.
+     */
+    audioBuildMultichannel(settings: AudioBuildMultichannelSettings): Promise<AudioBuildMultichannelNode>;
+    /**
+     * Split a multichannel audio stream into its individual channels. The first
+     * channel receives the specified stream key, and each subsequent channel
+     * increments the stream id on the stream key.
+     * @param settings - Settings for the splitter
+     */
+    audioSplitMultichannel(settings: AudioSplitMultichannelSettings): Promise<AudioSplitMultichannelNode>;
+    /**
+     * Encode an audio stream.
+     * @param settings - Settings for the encoder, including channel layout and
+     * bitrate.
+     */
+    audioEncode(settings: AudioEncodeSettings): Promise<AudioEncodeNode>;
+    /**
+     * A node to nudge the timestamps on a stream, which affects how it syncs
+     * with other streams. Useful for correcting for drift between different
+     * sources.
+     *
+     * Subsequent nudges, via the `nudge` method, are applied gradually.
+     *
+     * This functionality is also provided by a `nudge` method on many sources.
+     * @param settings - Initial nudge plus general node settings.
+     */
+    streamTimestampNudge(settings: StreamTimestampNudgeSettings): Promise<StreamTimestampNudgeNode>;
+    /**
+     * Provide a new stream key for a single stream. Cannot be subscribed to
+     * multiple streams at once.
+     *
+     * The stream key is used for identifying streams within multiplexed sources
+     * and also is translated into URIs for HLS playlists and other resources.
+     *
+     * This can be useful if changing sources and wanting to maintain a consistent
+     * streamkey going into an output
+     * @param settings - New stream key plus general node settings.
+     */
+    streamKeyOverride(settings: StreamKeyOverrideSettings): Promise<StreamKeyOverrideNode>;
+    /**
+     * Override bitrate and language metadata on streams.
+     *
+     * Audio and video bitrate metadata is required for playlists for the
+     * {@link NorskOutput.cmafMultiVariant} node.
+     * It is automatically configured for some sources (like RTMP) and in
+     * cases where re-encoding is done, but is unset for other sources (like SRT).
+     * @param settings - Bitrate and language metadata plus general node settings.
+     */
+    streamMetadataOverride(settings: StreamMetadataOverrideSettings): Promise<StreamMetadataOverrideNode>;
+    /**
+     * Buffer a stream for the specified number of milliseconds. This can be used
+     * to reduce or eliminate jitter.
+     * @param settings - Buffer delay time.
+     */
+    jitterBuffer(settings: JitterBufferSettings): Promise<JitterBufferNode>;
+    /**
+     * Sync multiple streams together by timestamps, queuing frames from streams
+     * that are behind the others. This is already included in most nodes,
+     * especially outputs.
+     */
+    streamSync(settings: StreamSyncSettings): Promise<StreamSyncNode>;
+    /**
+     * This processor does multiple things
+     * - joins together multiple streams from multiple sources
+     * - rebases their timestamps so that they all start at the same point
+     * - sets the program id to a common value
+     *
+     * It is useful for syncing multiple incoming streams that on paper are already synchronised but because
+     * of the time taken to set up connections and subscriptions across various protocols, are off by a few
+     * hundred milliseconds
+     */
+    streamAlign(settings: StreamAlignSettings): Promise<StreamAlignNode>;
+    /**
+     * Observe, modify or inject ancillary data such as SCTE-35
+     */
+    ancillary(settings: AncillarySettings): Promise<AncillaryNode>;
+    /**
+     * Combine compatible streams of metadata (this refers to ancillary streams of metadata messages, such as that
+     * carried in an MPEG-TS PES metadata stream (e.g. KLV), unrelated to operations on the metadata of audio/video/etc streams.
+     */
+    metadataCombine(settings: MetadataCombineSettings): Promise<MetadataCombineMode>;
+}
+
+/** @public */
+export declare interface NumaNode {
+    processors: Processor[];
+}
+
+/**
+ * @public
+ * Settings for a H264 Encode using Nvidia hardware
+ * A detailed description of these params can be found
+ * on the Nvidia Encoder Documentation
+ *
+ * If left undefined, all will default to Nvidia's own defaults
+ * If a preset is configured, then all will default to the values provided
+ * by that preset
+ * */
+export declare interface NvidiaH264 {
+    type: "nv-h264";
+    /** The preset to use for this encode */
+    preset?: NvidiaPreset;
+    /** The IDR period */
+    idrPeriod?: number;
+    /**The gopInterval to use for this encode
+     * Note: This is different from the idrPeriod but usually you want
+     * them set to the same value regardless
+     * */
+    gopInterval?: number;
+    /** This is the gop structure to be used, and again it's best to look this up
+     * in the Nvidia documentation
+     * */
+    frameIntervalP?: number;
+    /** This is somewhat related to the gop structure and again, care should be taken when overriding this from
+     * the preset */
+    maxNumRefFrames?: number;
+    /** The target level of this H264 encode
+     * Note: The behaviour of Nvidia is to error out if this is incompatible with the other settings
+     * this differs from other codecs which just silently change the outgoing level/profile for example */
+    level?: NvidiaH264Level;
+    /** The target profile of this H264 encode
+     * Note: The behaviour of Nvidia is to error out if this is incompatible with the other settings
+     * this differs from other codecs which just silently change the outgoing level/profile for example */
+    profile?: NvidiaH264Profile;
+    /** Output Access Unit Delimiters */
+    outputAud?: boolean;
+    /** Rate Control Settings */
+    rateControl?: NvidiaRateControl;
+}
+
+/**
+ * @public
+ * See the Nvidia Encoder Docs for a description of this value
+ * */
+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
+ * See the Nvidia Encoder Docs for a description of this value
+ * */
+export declare type NvidiaH264Profile = "baseline" | "main" | "high" | "high444";
+
+/**
+ * @public
+ * Settings for a HEVC Encode using Nvidia hardware
+ * A detailed description of these params can be found
+ * on the Nvidia Encoder Documentation
+ *
+ * If left undefined, all will default to Nvidia's own defaults
+ * If a preset is configured, then all will default to the values provided
+ * by that preset
+ * */
+export declare interface NvidiaHevc {
+    type: "nv-hevc";
+    /** The preset to use for this encode */
+    preset?: NvidiaPreset;
+    /** The IDR period */
+    idrPeriod?: number;
+    /**The gopInterval to use for this encode
+     * Note: This is different from the idrPeriod but usually you want
+     * them set to the same value regardless
+     * */
+    gopInterval?: number;
+    /** This is the gop structure to be used, and again it's best to look this up
+     * in the Nvidia documentation
+     * */
+    frameIntervalP?: number;
+    /** The target level of this HEVC encode
+     * Note: The behaviour of Nvidia is to error out if this is incompatible with the other settings
+     * this differs from other codecs which just silently change the outgoing level/profile for example */
+    level?: NvidiaHevcLevel;
+    /** The target profile of this HEVC encode
+     * Note: The behaviour of Nvidia is to error out if this is incompatible with the other settings
+     * this differs from other codecs which just silently change the outgoing level/profile for example */
+    profile?: NvidiaHevcProfile;
+    /** Output Access Unit Delimiters */
+    outputAud?: boolean;
+    /** The target tier of this HEVC encode
+     * Note: The behaviour of Nvidia is to error out if this is incompatible with the other settings
+     * this differs from other codecs which just silently change the outgoing level/profile for example */
+    tier?: NvidiaHevcTier;
+    /** Rate Control Settings */
+    rateControl?: NvidiaRateControl;
+}
+
+/**
+ * @public
+ * See the Nvidia Encoder Docs for a description of this value
+ * */
+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
+ * See the Nvidia Encoder Docs for a description of this value
+ * */
+export declare type NvidiaHevcProfile = "main" | "main10";
+
+/**
+ * @public
+ * See the Nvidia Encoder Docs for a description of this value
+ * */
+export declare type NvidiaHevcTier = "main" | "high";
+
+/**
+ * @public
+ * See the Nvidia Encoder Docs for a description of this value
+ * */
+export declare type NvidiaPreset = "p1" | "p2" | "p3" | "p4" | "p5" | "p6" | "p7";
+
+/**
+ * @public
+ * The rate control options for an nvidia encode
+ * For further info, consult the Nvidia Encoder docs
+ * */
+export declare interface NvidiaRateControl {
+    /** the mode to use for this rate control operation */
+    mode: NvidiaRateControlMode;
+    /** The average bitrate of this encode */
+    averageBitrate: number;
+    /** The max bitrate of this encode */
+    maxBitrate?: number;
+    /** The vbv buffer size used for this encode */
+    vbvBufferSize?: number;
+    /** The vbv initial delay used for this encode */
+    vbvInitialDelay?: number;
+    /** Enable lookahead or not:
+     * Note: enabling lookahead will introduce scene cuts unless this is specifically disabled
+     * elswhere in the codec settings
+     * */
+    enableLookahead?: boolean;
+    strictGopTarget?: boolean;
+    lookaheadDepth?: number;
+}
+
+/**
+ * @public
+ * See the Nvidia Encoder Docs for a description of this value
+ * */
+export declare type NvidiaRateControlMode = "con_stqp" | "vbr" | "cbr";
+
+/**
+ * @public
+ * A rectangle used for describing a subset of an image
+ * */
+export declare interface OffsetRect {
+    /** The leftmost coordinate of the rect, where 0,0 is top left */
+    x: number;
+    /** The topmost coordinate of the rect, where 0,0 is top left */
+    y: number;
+    /** the width of this rectangle */
+    width: number;
+    /** the height of this rectangle */
+    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
+ * Settings for an Opus encode
+ * see: {@link NorskTransform.audioEncode}
+ * */
+export declare interface OpusSettings {
+    kind: "opus";
+}
+
+/** @public
+ * A transition for a video composition part.
+ *
+ * A transition interpolates the source_rect, dest_rect, and opacity properties
+ * over the specified duration according to the specified easing function.
+ *
+ * As a special case, if a transition is specified and the input pin of the part
+ * changes, an opacity fade from one to the other will occur.
+ */
+export declare interface PartTransition {
+    /** Duration for the transition */
+    durationMs: number;
+    /**
+     * Easing function to apply to the transition. If not specified will be
+     * linear.
+     */
+    easing?: SimpleEasing;
+}
+
+declare type Pattern = "black" | "smpte75" | "smpte100";
+
+/** @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 type PlaylistOnChangeFn<ClientMessage> = {
+    cmafMediaPlaylist?: (grpcStream: grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, destinationId: DestinationId, additions: HlsPlaylistAdditions, playlistWithAdditions: HlsPlaylist) => void;
+    tsMediaPlaylist?: (grpcStream: grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, destinationId: DestinationId, additions: TsPlaylistAdditions, playlistWithAdditions: MediaPlaylistPart[]) => void;
+    cmafMultiVariantPlaylist?: (grpcStream: grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, destinationId: DestinationId, playlist: CmafMultiVariantPlaylistData) => void;
+    hlsTsMultiVariantPlaylist?: (grpcStream: grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, destinationId: DestinationId, playlist: string) => void;
+};
+
+/** @public */
+declare enum PlaylistPath {
+    Cmaf = 0,
+    Ts = 1
+}
+
+/**
+ * @public
+ * Returns the stream keys for playlist streams in a media context
+ * @param streams - The media context from which to return the stream keys
+ * @returns The playlist stream keys in the media context
+ */
+export declare function playlistStreamKeys(streams: readonly StreamMetadata[]): StreamKey[];
+
+/** @public */
+export declare interface PlaylistStreamMetadata {
+}
+
+/**
+ * @public
+ * Filters a context to only the playlist streams within it
+ * @param streams - The media context from which to return the streams
+ * @returns The playlist streams in the media context
+ */
+export declare function playlistStreams(streams: readonly StreamMetadata[]): StreamMetadata[];
+
+/** @public */
+export declare interface Processor {
+    cores: Core[];
+}
+
+export declare interface ProcessorMediaNode<Pins extends string> extends SourceMediaNode, AutoSinkMediaNode<Pins> {
+}
+
+export declare class ProcessorMediaNode<Pins extends string> {
+    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, getGrpcStream: () => (Readable | Writable), subscribeFn: (subscription: Subscription) => Promise<boolean>, subscribeErrorFn?: (error: SubscriptionError) => void, subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => void);
+}
+
+/** @public */
+export declare interface ProcessorNodeSettings<T extends MediaNodeState> extends SinkNodeSettings<T>, SourceNodeSettings<T> {
+}
+
+/** @public */
+export declare interface ProgramDateTime {
+    programDateTime: Date;
+}
+
+/** @public */
+export declare function publicUrlPrefix(): string;
+
+/**
+ * @public
+ * Settings for a H264 Encode using Netint Quadra hardware
+ * A detailed description of these params can be found
+ * on the Netint Quadra Encoder Documentation
+ *
+ * These fields have deliberately been written to maintain the same semantics as the
+ * Quadra documentation where possible.
+ *
+ * If left undefined, all will default to Quadra's own defaults
+ * */
+export declare interface QuadraH264 {
+    type: "quadra-h264";
+    /** This (for convenience) takes the xcoder string that Quadra's
+     * Ffmpeg integration accepts, this is to aid developers in getting up and running
+     * quickly and will override any values set manually in the rest of this interface.
+     *
+     * It is expected that developers will choose to use the typed fields for most things instead
+     * when moving to production, as they offer a degree of validation and type safety
+     * */
+    extraOpts?: string;
+    enableAud?: boolean;
+    gpuIndex?: number;
+    bitrate?: number;
+    enableVfr?: boolean;
+    crf?: number;
+    gopPresetIndex?: number;
+    intraPeriod?: number;
+    rcEnable?: boolean;
+    intraQp?: number;
+    rcInitDelay?: number;
+    profile?: QuadraH264Profile;
+    level?: QuadraH264Level;
+    fillerEnable?: boolean;
+    minQp?: number;
+    maxQp?: number;
+    maxDeltaQp?: number;
+    cuLevelRCEnable?: boolean;
+    lookAheadDepth?: number;
+    vbvBufferSize?: number;
+    vbvMaxRate?: number;
+}
+
+/** @public */
+export declare type QuadraH264Level = 1 | 2 | 2.1 | 3 | 3.1 | 4 | 4.1 | 5 | 5.1 | 5.2 | 6 | 6.1 | 6.2;
+
+/** @public */
+export declare type QuadraH264Profile = "baseline" | "main" | "extended" | "high" | "high10";
+
+/**
+ * @public
+ * Settings for a HEVC Encode using Netint Quadra hardware
+ * A detailed description of these params can be found
+ * on the Netint Quadra Encoder Documentation
+ *
+ * These fields have deliberately been written to maintain the same semantics as the
+ * Quadra documentation where possible.
+ *
+ * If left undefined, all will default to Quadra's own defaults
+ * */
+export declare interface QuadraHevc {
+    type: "quadra-hevc";
+    /** This (for convenience) takes the xcoder string that Quadra's
+     * Ffmpeg integration accepts, this is to aid developers in getting up and running
+     * quickly and will override any values set manually in the rest of this interface.
+     *
+     * It is expected that developers will choose to use the typed fields for most things instead
+     * when moving to production, as they offer a degree of validation and type safety
+     * */
+    extraOpts?: string;
+    enableAud?: boolean;
+    gpuIndex?: number;
+    bitrate?: number;
+    enableVfr?: boolean;
+    crf?: number;
+    gopPresetIndex?: number;
+    intraPeriod?: number;
+    rcEnable?: boolean;
+    intraQp?: number;
+    rcInitDelay?: number;
+    profile?: QuadraHevcProfile;
+    level?: QuadraHevcLevel;
+    tier?: QuadraHevcTier;
+    lossless?: boolean;
+    hrdEnable?: boolean;
+    dolbyVisionProfile?: number;
+    fillerEnable?: boolean;
+    minQp?: number;
+    maxQp?: number;
+    maxDeltaQp?: number;
+    cuLevelRCEnable?: boolean;
+    lookAheadDepth?: number;
+    vbvBufferSize?: number;
+    vbvMaxRate?: number;
+}
+
+/** @public */
+export declare type QuadraHevcLevel = 1 | 2 | 2.1 | 3 | 3.1 | 4 | 4.1 | 5 | 5.1 | 5.2 | 6 | 6.1 | 6.2;
+
+/** @public */
+export declare type QuadraHevcProfile = "main" | "main10";
+
+/** @public */
+export declare type QuadraHevcTier = "main" | "high";
+
+/** @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
+ * Base settings for any input node requiring access to a host:port pair
+ * */
+export declare interface RemoteInputSettings<T extends MediaNodeState> extends InputSettings<T> {
+    /** The IP of the remote server*/
+    ip: string;
+    /** The port the remote server is listening on*/
+    port: number;
+}
+
+/**
+ * @public
+ * Validation function to require at least one audio and at least one video stream. Often the default validation
+ * will happen to ensure this, as audio and video are subscribed from separate media nodes, but when one media node
+ * will produce both audio and video, default validation cannot know that both are required.
+ */
+export declare function requireAV(ctx: Context): boolean;
+
+/**
+ * @public
+ * Validation function to require exactly N audio and exactly M video streams. Often the default validation
+ * will happen to ensure this, as audio and video are subscribed from separate media nodes, but when one media node
+ * will produce both audio and video, default validation cannot know that both are required.
+ */
+export declare function requireExactAV({ audio, video }: {
+    audio: number;
+    video: number;
+}): (ctx: Context) => boolean;
+
+/**
+ * @public
+ * The resolution of a video within Norsk
+ * */
+export declare interface Resolution {
+    width: number;
+    height: number;
+}
+
+/** @public */
+export declare enum RtmpConnectionFailureReason {
+    RtmpConnectionFailedRetry = "RtmpConnectionFailedRetry"
+}
+
+/**
+ * @public
+ * see: {@link NorskOutput.rtmp}
+ */
+export declare class RtmpOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+}
+
+/**
+ * @public
+ * The settings for an RTMP output
+ * see: {@link NorskOutput.rtmp}
+ * */
+export declare interface RtmpOutputSettings extends SinkNodeSettings<RtmpOutputNode>, StreamStatisticsMixin {
+    /**
+     * The URL of the remote RTMP server to connect to, including the full stream path and credentials
+     */
+    url: string;
+    /** Jitter buffer delay in milliseconds */
+    bufferDelayMs?: number;
+    /** A/V delay in milliseconds (to allow embedded captions to be added) */
+    avDelayMs?: number;
+    /** Called when the RTMP output succesfully connects to a server and starts publishing data */
+    onPublishStart?: () => void;
+    /** Called when the connection to the RTMP server fails */
+    onConnectionFailure?: (failureReason: RtmpConnectionFailureReason) => void;
+    /**
+     * Number of seconds to wait until a retry is attempted to the RTMP server.
+     * Defaults to five seconds
+     */
+    retryConnectionTimeout?: number;
+    sslOptions?: {
+        verifyPeerCert?: boolean;
+    };
+}
+
+/**
+ * @public
+ * see: {@link NorskInput.rtmpServer}
+ */
+export declare class RtmpServerInputNode extends SourceMediaNode {
+    /**
+     * @public
+     * Applies a gradual nudge to the outgoing stream timestamps by the specified number of milliseconds
+     * */
+    nudge(sourceName: string, programNumber: number, nudge: number): void;
+}
+
+/**
+ * @public
+ * Settings to control how RTMP streams can be included as sources in your media workflow
+ * see: {@link NorskInput.rtmpServer}
+ */
+export declare interface RtmpServerInputSettings extends SourceNodeSettings<RtmpServerInputNode>, StreamStatisticsMixin {
+    /** The port the RTMP server should listen on */
+    port?: number;
+    ssl?: boolean;
+    sslOptions?: {
+        certFile?: string;
+        keyFile?: string;
+    };
+    /**
+     * On connect callback, use to accept/reject connections given app/url in use
+     * @eventProperty
+     */
+    onConnection?: (
+    /** The connection ID, unique to this RtmpServer node */
+    connectionId: string, 
+    /** 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 connection ID, unique to this RtmpServer node */
+    connectionId: string, 
+    /** 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 connection ID, unique to this RtmpServer node */
+    connectionId: string, 
+    /** The new connection state */
+    status: RtmpServerInputStatus, 
+    /** 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;
+    onConnectionError?: (
+    /** The connection ID, unique to this RtmpServer node */
+    connectionId: string, 
+    /** The error */
+    error: RtmpError_UnsupportedVideo | RtmpError_UnsupportedAudio) => void;
+    onConnectionBytesRead?: (
+    /** The connection ID, unique to this RtmpServer node */
+    connectionId: string, 
+    /** The number of bytes read, as reported by the peer */
+    bytesRead: bigint) => void;
+}
+
+/** @public */
+export declare type RtmpServerInputStatus = "disconnected";
+
+/**
+ * @public
+ * The stream keys in an RTMP input stream
+ */
+export declare type RtmpServerStreamKeys = {
+    audioStreamKey: StreamKey_2;
+    videoStreamKey: StreamKey_2;
+}[];
+
+/**
+ * @public
+ * A description of an Eac3 stream being delivered via RTP
+ * */
+export declare interface RtpEac3 {
+    kind: "eac3";
+    /** The clock rate of the stream */
+    clockRate: number;
+    /** The language code (this will end up in outgoing metadata). RFC 5646 language tag. */
+    languageCode?: string;
+    ec3Extension: boolean;
+    complexityIndex: number;
+}
+
+/**
+ * @public
+ * A description of an H264 stream delivered over RTP
+ * */
+export declare interface RtpH264 {
+    kind: "h264";
+    /** The clock rate of the stream */
+    clockRate: number;
+}
+
+/**
+ * @public
+ * A description of an HEVC stream delivered over RTP
+ * */
+export declare interface RtpHEVC {
+    kind: "hevc";
+    /** The clock rate of the stream */
+    clockRate: number;
+}
+
+/**
+ * @public
+ * see: {@link NorskInput.rtp}
+ */
+export declare class RtpInputNode extends SourceMediaNode {
+    /**
+     * @public
+     * Applies a gradual nudge to the outgoing stream timestamps by the specified number of milliseconds
+     * */
+    nudge(nudge: number): void;
+}
+
+/**
+ * @public
+ * Settings for an RTP input
+ * see: {@link NorskInput.rtp}
+ * */
+export declare interface RtpInputSettings extends SourceNodeSettings<RtpInputNode>, StreamStatisticsMixin {
+    sourceName: string;
+    streams: readonly RtpStreamSettings[];
+}
+
+/**
+ * @public
+ * A description of a LinearPCM stream being delivered via RTP
+ * */
+export declare interface RtpLinearPcm {
+    kind: "linearpcm";
+    /** The sample rate of the stream */
+    sampleRate: SampleRate;
+    /** The channel layotu the stream */
+    channelLayout: ChannelLayout;
+    /** The bit depth of the stream */
+    bitDepth: RtpLinearPcmBitDepth;
+}
+
+/** @public */
+export declare type RtpLinearPcmBitDepth = 16 | 24;
+
+/**
+ * @public
+ * A description of a Mpeg4 Generic Aac stream
+ * */
+export declare interface RtpMpeg4GenericAacHbr {
+    kind: "mpeg4-generic-aac-hbr";
+    config: string;
+}
+
+/**
+ * @public
+ * A description of an incoming RTP stream
+ * */
+export declare interface RtpStreamSettings {
+    /** A streamID to assign to the outgoing stream key */
+    streamId: number;
+    /** The IP Address to join the RTP stream on */
+    ip: string;
+    /** The interface to bind to, "loopback" and "any" are special cases
+     * and anything else will be interpreted as the name of a network interface */
+    interface: string;
+    /** The port to connect to for the RTP stream itself */
+    rtpPort: number;
+    /** The port to connect to for the associated RTCP stream */
+    rtcpPort: number;
+    /** A description of the stream being joined */
+    streamType: RtpLinearPcm | RtpEac3 | RtpMpeg4GenericAacHbr | RtpH264 | RtpHEVC;
+}
+
+/**
+ * @public
+ * This is the SAR/PAR for a video stream and is an expression of what shape each pixel has within a video stream
+ * x:1, y:1 being a square and the most common value for this
+ * */
+export declare interface SampleAspectRatio {
+    x: number;
+    y: number;
+}
+
+/** @public */
+export declare type SampleFormat = 
+/** Signed 16 bits, non-planar */
+"s16"
+/** Signed 16 bits, planar */
+| "s16p"
+/** 32bit floating point, non-planar */
+| "flt"
+/** 32bit floating point, planar */
+| "fltp";
+
+/** @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 type ScheduleComponent = {
+    components: Scte35ScheduleCommandComponent[];
+};
+
+/** @public */
+export declare type ScheduledTag = [number, MediaPlaylistPart, Date, DestinationId?];
+
+/** @public */
+export declare type ScheduleProgram = {
+    utcSpliceTime: number;
+};
+
+/** @public */
+export declare type Scte35AudioComponent = {
+    componentTag: number;
+    isoCode: number;
+    bitStreamMode: number;
+    numChannels: number;
+    fullSrvcAudio: boolean;
+};
+
+/** @public */
+export declare type Scte35AudioDescriptor = {
+    components: Scte35AudioComponent[];
+};
+
+/** @public */
+export declare type Scte35AvailDescriptor = {
+    providerAvailId: number;
+};
+
+/** @public */
+export declare type Scte35BreakDuration = {
+    autoReturn: boolean;
+    duration: bigint;
+};
+
+/** @public */
+export declare type Scte35DtmfDescriptor = {
+    preroll: number;
+    dtmfChars: Uint8Array;
+};
+
+/** @public */
+export declare type Scte35GenericDescriptor = {
+    identifier: number;
+    spliceDescriptorTag: number;
+    privateBytes: Uint8Array;
+};
+
+/** @public */
+export declare type Scte35InsertCommand = {
+    spliceEventId: number;
+    spliceEventCancelIndicator: boolean;
+    outOfNetworkIndicator: boolean;
+    spliceImmediateFlag: boolean;
+    mode: Scte35InsertCommandMode;
+    breakDuration: Scte35BreakDuration;
+    uniqueProgramId: number;
+    availNum: number;
+    availsExpected: number;
+};
+
+/** @public */
+export declare type Scte35InsertCommandComponent = {
+    componentTag: number;
+    spliceTime: Scte35SpliceTime;
+};
+
+/** @public */
+export declare type Scte35InsertCommandMode = InsertProgram | InsertComponent;
+
+/** @public */
+export declare type Scte35PrivateCommand = {
+    identifier: number;
+    privateBytes: Uint8Array;
+};
+
+/** @public */
+export declare type Scte35ReservedCommand = {
+    reserved: number;
+};
+
+/** @public */
+export declare type Scte35ScheduleCommand = {
+    items: Scte35ScheduleItem[];
+};
+
+/** @public */
+export declare type Scte35ScheduleCommandComponent = {
+    componentTag: number;
+    utcSpliceTime: number;
+};
+
+/** @public */
+export declare type Scte35ScheduleCommandMode = ScheduleProgram | ScheduleComponent;
+
+/** @public */
+export declare type Scte35ScheduleItem = {
+    spliceEventId: number;
+    spliceEventCancelIndicator: boolean;
+    outOfNetworkIndicator: boolean;
+    mode: Scte35ScheduleCommandMode;
+    breakDuration: Scte35BreakDuration;
+    uniqueProgramId: number;
+    availNum: number;
+    availsExpected: number;
+};
+
+/** @public */
+export declare type Scte35SegmentationComponent = {
+    componentTag: number;
+    ptsOffset: bigint;
+};
+
+/** @public */
+export declare type Scte35SegmentationDescriptor = {
+    segmentationEventId: number;
+    segmentationEventCancelIndicator: boolean;
+    programSegmentationFlag: boolean;
+    deliveryRestrictions?: Scte35SegmentDeliveryRestrictions;
+    components: Scte35SegmentationComponent[];
+    segmentationDuration?: bigint;
+    segmentationUpidType: number;
+    segmentationUpid: Uint8Array;
+    segmentationTypeId: number;
+    segmentNum: number;
+    segmentsExpected: number;
+    subSegmentNum?: number;
+    subSegmentsExpected?: number;
+};
+
+/** @public */
+export declare type Scte35SegmentDeliveryRestrictions = {
+    webDeliveryAllowedFlag: boolean;
+    noRegionalBlackoutFlag: boolean;
+    archiveAllowedFlag: boolean;
+    deviceRestrictions: number;
+};
+
+/** @public */
+export declare type Scte35SpliceCommand = {
+    type: Scte35SpliceCommandType;
+    value?: Scte35InsertCommand | Scte35ScheduleCommand | Scte35TimeSignalCommand | Scte35PrivateCommand | Scte35ReservedCommand;
+};
+
+/** @public */
+export declare type Scte35SpliceCommandType = "null" | "schedule" | "insert" | "timeSignal" | "bandwidthReservation" | "privateCommand" | "reserved";
+
+/** @public */
+export declare type Scte35SpliceDescriptor = {
+    type: Scte35SpliceDescriptorType;
+    value: Scte35AvailDescriptor | Scte35DtmfDescriptor | Scte35SegmentationDescriptor | Scte35TimeDescriptor | Scte35AudioDescriptor | Scte35GenericDescriptor;
+};
+
+/** @public */
+/** @public */
+export declare type Scte35SpliceDescriptorType = "avail" | "dtmf" | "segmentation" | "time" | "audio" | "generic";
+
+/** @public */
+export declare type Scte35SpliceInfoSection = {
+    sapType: number;
+    protocolVersion: number;
+    encryptedPacket: boolean;
+    encryptionAlgorithm: number;
+    ptsAdjustment: bigint;
+    cwIndex: number;
+    tier: number;
+    spliceCommand: Scte35SpliceCommand;
+    descriptors: Scte35SpliceDescriptor[];
+};
+
+/** @public */
+export declare type Scte35SpliceTime = {
+    ptsTime?: number;
+};
+
+/** @public */
+export declare type Scte35TimeDescriptor = {
+    taiSeconds: bigint;
+    taiNs: number;
+    utcOffset: number;
+};
+
+/** @public */
+export declare type Scte35TimeSignalCommand = {
+    spliceTime: Scte35SpliceTime;
+};
+
+/**
+ * @public
+ * Select all the streams from the input
+ * @param streams - The streams from the inbound Context
+ * @returns Array of selected StreamKeys
+ */
+export declare function selectAll(streams: readonly StreamMetadata[]): StreamKey[];
+
+/**
+ * @public
+ * Select all the ancillary data streams from the input
+ * @param streams - The streams from the inbound Context
+ * @returns Array of selected StreamKeys
+ */
+export declare function selectAncillary(streams: readonly StreamMetadata[]): StreamKey[];
+
+/**
+ * @public
+ * Select all the audio streams from the input
+ * @param streams - The streams from the inbound Context
+ * @returns Array of selected StreamKeys
+ */
+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 selectExactKey(key: StreamKey): (streams: readonly StreamMetadata[]) => StreamKey[];
+
+/** @public */
+export declare function selectPlaylist(streams: readonly StreamMetadata[]): StreamKey[];
+
+/**
+ * @public
+ * Select all the subtitle streams from the input
+ * @param streams - The streams from the inbound Context
+ * @returns Array of selected StreamKeys
+ */
+export declare function selectSubtitles(streams: readonly StreamMetadata[]): StreamKey[];
+
+/**
+ * @public
+ * Select all the video streams from the input
+ * @param streams - The streams from the inbound Context
+ * @returns Array of selected StreamKeys
+ */
+export declare function selectVideo(streams: readonly StreamMetadata[]): StreamKey[];
+
+/**
+ * @public
+ * Create a selector selecting all the video streams from the input with the specified rendition name
+ * @param renditionName - The streams from the inbound Context
+ * @returns Array of selected StreamKeys
+ */
+export declare function selectVideoRendition(renditionName: string): (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 SingleStreamStatistics extends StreamStatistics {
+    streamKey: StreamKey;
+    metadata: StreamMetadataMessage;
+}
+
+/** @public */
+export declare class SinkMediaNode<Pins extends string> extends MediaNodeState implements SubscribeDestination {
+    permissiveSubscriptionValidation(_context: Context): SubscriptionValidationResponse;
+    restrictiveSubscriptionValidation(context: Context): SubscriptionValidationResponse;
+    /** 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.
+     *
+     * @param done - will be called with no arguments if the subscription succeeds,
+     * or an error if it failed. This error indicates the specific reason it
+     * failed, so you can take appropriate actions in response. It will be called
+     * before the `subscribedStreamsChangedFn` or `subscribeErrorFn` callbacks
+     * provided in the config for the node.
+     *
+     * Errors are also logged to the debug log.
+     */
+    subscribeToPins(sources: ReceiveFromAddress<Pins>[], validation?: (context: Context) => SubscriptionValidationResponse, done?: (error?: SubscriptionError) => void): void;
+    sourceContextChange(responseCallback: (error?: SubscriptionError) => void): Promise<boolean>;
+    finalise(): void;
+}
+
+/** @public */
+export declare interface SinkNodeSettings<T extends MediaNodeState> extends NodeSettings<T> {
+    onSubscriptionError?: (error: SubscriptionError) => void;
+}
+
+export declare interface Smpte2038Message {
+    cNotYChannelFlag: boolean;
+    lineNumber: number;
+    horizontalOffset: number;
+    payloadFormat: VancPayloadFormat;
+    ancillaryId: VancType2AncillaryId;
+    userData: Uint8Array;
+}
+
+/** @public */
+export declare class SourceMediaNode extends MediaNodeState {
+    outputStreams: StreamMetadata[];
+    registerForContextChange(subscriber: SubscribeDestination): void;
+    unregisterForContextChange(subscriber: SubscribeDestination): void;
+}
+
+/** @public */
+export declare interface SourceNodeSettings<T extends MediaNodeState> extends NodeSettings<T> {
+    onOutboundContextChange?: (streams: StreamMetadata[]) => Promise<void>;
+}
+
+/**
+ * @public
+ * Errors found while subscribing to a particular source, separated out by reason:
+ *
+ * - `internal`: An opaque internal error
+ *
+ * - `unknownSourceId`: The media node does not exist (maybe it crashed)
+ *
+ * - `unknownSourceStream`: The media node exists, but does not have the stream key
+ *
+ * - `noSubscriberPin`: The media node is not set up to receive data on this pin (which may be auto-detected)
+ *
+ * - `unsupportedConversion`: Norsk does not support conversion from the media types of the source to the media types accepted by the subscriber
+ */
+export declare type SourceSubscriptionError = {
+    info: string;
+    reason: "internal";
+} | {
+    mediaNodeId: MediaNodeId;
+    reason: "unknownSourceId";
+} | {
+    mediaNodeId: MediaNodeId;
+    streamKey: StreamKey;
+    reason: "unknownSourceStream";
+} | {
+    mediaNodeId: MediaNodeId;
+    streamKey: StreamKey;
+    pin: string;
+    subscriberPins: string[];
+    reason: "noSubscriberPin";
+} | {
+    mediaNodeId: MediaNodeId;
+    streamKey: StreamKey;
+    sourceTypes: string[];
+    subscriberTypes: string[];
+    reason: "unsupportedConversion";
+};
+
+/** @public */
+export declare function sourceToPin<Pins extends string>(source: string, pin: Pins): (streams: StreamMetadata[]) => PinToKey<Pins>;
+
+/**
+ * @public
+ * The return value for the {@link SrtInputSettings.onConnection} callback
+ * determining what to do with an incoming stream
+ */
+export declare type SrtConnectionResult = 
+/** Accept the stream */
+    {
+    accept: true;
+    /** The source name to assign to the connection */
+    sourceName: string;
+}
+/** Reject the stream */
+| {
+    accept: false;
+};
+
+/**
+ * @public
+ * see: {@link NorskInput.srt}
+ */
+export declare class SrtInputNode extends SourceMediaNode {
+    /**
+     * @public
+     * Applies a gradual nudge to the outgoing stream timestamps by the specified number of milliseconds
+     * */
+    nudge(sourceName: string, programNumber: number, nudge: number): void;
+    /**
+     * @public
+     * Closes a connected stream as specified by 'streamIndex'
+     * @param streamIndex - the index of the stream to be terminated
+     * */
+    closeStream(streamIndex: number): void;
+}
+
+/**
+ * @public
+ * Settings for an SRT Input node
+ * see: {@link NorskInput.srt}
+ */
+export declare interface SrtInputSettings extends RemoteInputSettings<SrtInputNode>, StreamStatisticsMixin {
+    /**
+     * The mode to act in (caller or listener)
+     */
+    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, 
+    /**
+     * Identifier indicating which connection this message refers to (for a
+     * listener which may have multiple connections)
+     */
+    index: number, 
+    /** The address of the remote host */
+    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
+ * see: {@link NorskOutput.srt}
+ */
+export declare class SrtOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+}
+
+/**
+ * @public
+ * The settings for an SRT output
+ * see: {@link NorskOutput.srt}
+ * */
+export declare interface SrtOutputSettings extends SinkNodeSettings<SrtOutputNode>, StreamStatisticsMixin {
+    /**
+     * Passphrase for encryption
+     */
+    passphrase?: string;
+    /**
+     * Stream ID to set on the socket when acting in caller mode
+     */
+    streamId?: string;
+    /**
+     * The mode to act in (see {@link SrtMode})
+     */
+    mode: SrtMode;
+    /**
+     * The IP address to listen on in listener mode, or to connect to in caller mode
+     */
+    ip: string;
+    /**
+     * The port to listen on in listener mode, or to connect to in caller mode
+     */
+    port: number;
+    /** Jitter buffer delay in milliseconds */
+    bufferDelayMs?: number;
+    /** A/V delay in milliseconds - to allow inclusion of subtitles, metadata and other ancillary data. May be set to 0 if these are not present to reduce latency */
+    avDelayMs?: 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
+ * see: {@link NorskTransform.streamSync}
+ */
+export declare class StreamAlignNode extends AutoProcessorMediaNode<"audio" | "video"> {
+}
+
+/**
+ * @public
+ * Settings for a StreamAlign node
+ * This will reset all streams to the same framerates/sample rates
+ * and align their timestamps so that they completely line up for downstream operations
+ * see {@link NorskTransform.streamAlign}
+ * */
+export declare interface StreamAlignSettings extends ProcessorNodeSettings<StreamAlignNode> {
+    sampleRate: SampleRate;
+    frameRate: FrameRate;
+}
+
+/**
+ * @public
+ * see: {@link NorskTransform.streamChaosMonkey}
+ */
+export declare class StreamChaosMonkeyNode extends AutoProcessorMediaNode<"audio" | "video" | "subtitle"> {
+}
+
+/**
+ * @public
+ * The settings for a Chaos Monkey
+ * see: {@link NorskTransform.streamChaosMonkey}
+ * */
+export declare interface StreamChaosMonkeySettings extends ProcessorNodeSettings<StreamChaosMonkeyNode> {
+    /** Optional configuration to drop frames from a stream
+     * leaving this undefined means don't drop any frames
+     * */
+    frameDrop?: DropRandom | DropEvery | DropStart;
+    /**
+     * Introduce random jitter
+     */
+    jitterMs?: number;
+}
+
+/** @public */
+export declare interface StreamKey {
+    streamId: number;
+    programNumber: number;
+    sourceName: string;
+    renditionName: string;
+}
+
+/**
+ * @public
+ * see: {@link NorskTransform.streamKeyOverride}
+ */
+export declare class StreamKeyOverrideNode extends AutoProcessorMediaNode<"audio" | "video" | "subtitle"> {
+}
+
+/**
+ * @public
+ * Settings for a Stream Key Override
+ * see: {@link NorskTransform.streamKeyOverride}
+ * */
+export declare interface StreamKeyOverrideSettings extends ProcessorNodeSettings<StreamKeyOverrideNode> {
+    /** The stream key that all frames passing through this node will be assigned */
+    streamKey: StreamKey;
+}
+
+/**
+ * Compares two stream keys by value, returning true if the stream keys refer to the same stream
+ */
+export declare function streamKeysAreEqual(l: StreamKey, r: StreamKey): unknown;
+
+/** @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: "playlist";
+    value: PlaylistStreamMetadata;
+} | {
+    case: "ancillary";
+    value: AncillaryStreamMetadata;
+} | {
+    case: undefined;
+    value?: undefined;
+};
+
+/**
+ * @public
+ * see: {@link NorskTransform.streamMetadataOverride}
+ */
+export declare class StreamMetadataOverrideNode extends AutoProcessorMediaNode<"audio" | "video" | "subtitle"> {
+    /**
+     * @public
+     * Updates the config used by this metadata override node for all subsequent frames
+     * @param settings - The new settings
+     */
+    updateConfig(settings: StreamMetadataOverrideSettingsUpdate): void;
+}
+
+/**
+ * @public
+ * Settings for a Stream Metadata Override Node
+ * see: {@link NorskTransform.streamMetadataOverride}
+ * */
+export declare interface StreamMetadataOverrideSettings extends ProcessorNodeSettings<StreamMetadataOverrideNode>, StreamMetadataOverrideSettingsUpdate {
+}
+
+/** @public */
+export declare interface StreamMetadataOverrideSettingsUpdate {
+    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. RFC 5646 language tag. */
+        language?: string;
+    };
+    subtitles?: {
+        /** Override the language metadata of a subtitles stream, or `""` to clear. RFC 5646 language tag. */
+        language?: string;
+    };
+}
+
+/** @public */
+export declare interface StreamStatistics {
+    /** 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 StreamStatisticsMixin {
+    /**
+     * Sampling rates for stream stats, in seconds
+     */
+    statsSampling?: PlainMessage<StreamStatisticsSampling>;
+    /**
+     * Called at periodic intervals when stream statistics are ready.
+     * @eventProperty
+     */
+    onStreamStatistics?: (
+    /** The stats */
+    stats: MultiStreamStatistics) => void;
+    onGopStructure?: (structure: GopStructure) => void;
+}
+
+/**
+ * @public
+ * see {@link NorskControl.streamStatistics}.
+ */
+export declare class StreamStatisticsNode extends AutoProcessorMediaNode<"audio" | "video"> {
+}
+
+/**
+ * @public
+ * Settings for a Stream Statistics Node
+ * see: {@link NorskControl.streamStatistics}
+ */
+export declare interface StreamStatisticsSettings extends ProcessorNodeSettings<StreamStatisticsNode>, StreamStatisticsMixin {
+    /**
+     * Called periodically with the stream stats
+     * @param stats - The statistics for the stream
+     * @eventProperty
+     */
+    onStreamStatistics: (stats: MultiStreamStatistics) => void;
+    /**
+     * Sampling rates for stream stats, in seconds
+     */
+    statsSampling?: PlainMessage<StreamStatisticsSampling>;
+}
+
+/**
+ * @public
+ * see: {@link NorskControl.streamSwitchHard}
+ */
+export declare class StreamSwitchHardNode<Pins extends string> extends ProcessorMediaNode<Pins> {
+    switchSource(newSource: Pins): void;
+}
+
+/**
+ * @public
+ * Settings for the Hard Stream Switch
+ * see: {@link NorskControl.streamSwitchHard}
+ * */
+export declare interface StreamSwitchHardSettings<Pins extends string> extends ProcessorNodeSettings<StreamSwitchHardNode<Pins>> {
+    /** The currently active source to display on the output */
+    activeSource: Pins;
+    /** the source name to give the output of this switch operation */
+    outputSource: string;
+}
+
+/** @public */
+export declare type StreamSwitchSmoothHardwareAcceleration = 
+/**
+* Use the quadra overlay functionality to perform the compose
+*/
+"quadra"
+/**
+* Use an nvidia CUDA kernel to perform the compose
+*/
+| "nvidia";
+
+/**
+ * @public
+ * see: {@link NorskControl.streamSwitchSmooth}
+ */
+export declare class StreamSwitchSmoothNode<Pins extends string> extends ProcessorMediaNode<Pins> {
+    /**
+     * @public
+     * Switches the source used for the current output of this node
+     */
+    switchSource(newSource: Pins): void;
+}
+
+/**
+ * @public
+ * Settings for the Smooth Source Switch
+ * see {@link NorskControl.streamSwitchSmooth}
+ * */
+export declare interface StreamSwitchSmoothSettings<Pins extends string> extends ProcessorNodeSettings<StreamSwitchSmoothNode<Pins>> {
+    /** The presently active source being used to generate output for this node */
+    activeSource?: Pins;
+    /** The source name given to the output of this node */
+    outputSource: string;
+    /** How many milliseconds to use for the fade operation between two sources */
+    transitionDurationMs?: number;
+    /** The constant resolution that all output video will be scaled to */
+    outputResolution: Resolution;
+    /** The constant framerate that all output video will be sampled to */
+    frameRate: FrameRate;
+    /** The constant samplerate that all output audio will be resampled to */
+    sampleRate: SampleRate;
+    /** The constant channel layout that all output audio will be resampled to */
+    channelLayout: ChannelLayout;
+    /** Alignment behaviour of the component
+     * whether to rebase all incoming streams to a common timeline
+     * Note: This will modify the timestamps, meaning that merging streams not involved in this may result in
+     * operation may result in sync issues. To avoid this, you can use {@link NorskProcessor.streamAlign} instead of relying
+     * on this component for this behaviour
+     * Note: This behaviour may be removed in a future release and replaced with something similar
+     * */
+    alignment?: "aligned" | "not_aligned";
+    /** Callback which will be called if a switch request cannot be fulfilled */
+    onSwitchError?: (message: string, inputPin?: Pins) => void;
+    /** Callback which will be called a transition has succesfully completed for a requested switch, i.e. the new source
+     * is now showing.
+     *
+     * Note that if additional transitions are triggered when a transition is already in progress, a notification may only be
+     * given for the last transition to finish.
+     **/
+    onTransitionComplete?: (inputPin: Pins) => void;
+    /**
+     * Callback to be called when inbound context changes on some input; presence of an
+     * input means that media has arrived and is ready to switch
+     * immediately
+     * @param allStreams The collection of input contexts received over all input pins
+     */
+    onInboundContextChange?: (allStreams: Map<Pins, StreamMetadata[]>) => Promise<void>;
+    /**
+     * Optionally attempt to perform the compose operation on hardware
+     */
+    hardwareAcceleration?: ComposeHardwareAcceleration;
+}
+
+/**
+ * @public
+ * see: {@link NorskTransform.streamSync}
+ */
+export declare class StreamSyncNode extends AutoProcessorMediaNode<"audio" | "video"> {
+}
+
+/**
+ * @public
+ * Settings for a StreamSync node
+ * see {@link NorskTransform.streamSync}
+ * */
+export declare interface StreamSyncSettings extends ProcessorNodeSettings<StreamSyncNode> {
+}
+
+/**
+ * @public
+ * see: {@link NorskTransform.streamTimestampNudge}
+ */
+export declare class StreamTimestampNudgeNode extends AutoProcessorMediaNode<"audio" | "video"> {
+    /**
+     * @public
+     * Applies a gradual nudge to the stream timestamps by the specified number of milliseconds
+     * */
+    nudge(nudge: number): void;
+}
+
+/**
+ * @public
+ * Settings for a Stream Timestamp Nudge
+ * see: {@link NorskTransform.streamTimestampNudge}
+ * */
+export declare interface StreamTimestampNudgeSettings extends ProcessorNodeSettings<StreamTimestampNudgeNode> {
+    nudge?: number;
+}
+
+/**
+ * @public
+ * see: {@link NorskDebug.streamTimestampReport}
+ */
+export declare class StreamTimestampReportNode extends AutoSinkMediaNode<string> {
+}
+
+/**
+ * @public
+ * Settings to control MP4 file output
+ * see {@link NorskOutput.fileMp4}
+ */
+export declare interface StreamTimestampReportSettings extends SinkNodeSettings<StreamTimestampReportNode> {
+    onTimestamp?: (streamKey: StreamKey, timestamp: IntervalTimestamp) => Promise<void>;
+}
+
+export declare interface SubscribeDestination {
+    id?: string;
+    sourceContextChange(responseCallback: (error?: SubscriptionError) => void): Promise<boolean>;
+}
+
+/**
+ * @public
+ * Errors found while setting up subscriptions, separated out by reason:
+ *
+ * - `internal`: An opaque internal error
+ *
+ * - `unknownSubscriber`: The media node requesting the subscription does not exist
+ *
+ * - `multipleStreams`: Multiple stream keys found for the context type
+ *
+ * - `sourceSubscriptionError`: Per-source errors
+ */
+export declare type SubscriptionError = {
+    info: string;
+    reason: "internal";
+} | {
+    mediaNodeId: MediaNodeId;
+    reason: "unknownSubscriber";
+} | {
+    contextType: ContextType;
+    streamKeys: StreamKey[];
+    reason: "multipleStreams";
+} | {
+    sourceErrors: SourceSubscriptionError[];
+    reason: "sourceSubscriptionError";
+};
+
+/**
+ * @public
+ * Determines what to do with an incoming context
+ *
+ * - true/accept: Allow the incoming context through, and any subsequent/queued data that belongs to it
+ * - false/deny: Deny the incoming context, if no context has been accepted, then queue data until one is
+ * - accept_and_terminate: Allow the incoming context, then deny further data, flush and shut down the node
+ *      this is useful for cleanly terminating outputs when the context is empty
+ * - deny_and_queue: Deny the incoming context, and revert to the original queueing behaviour as if no context has been accepted
+ *      this is useful when switching from one full context to another, avoiding any "in-between"
+ * */
+export declare type SubscriptionValidationResponse = true | false | "accept" | "deny" | "accept_and_terminate" | "deny_and_queue";
+
+/** @public */
+export declare function 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[];
+
+declare class TsCommonInputNode<SourceMessage, T extends SourceMediaNode> extends SourceMediaNode {
+    constructor(tsType: TsInputType, client: MediaClient, unregisterNode: (node: MediaNodeState) => void, settings: SourceNodeSettings<T> & StreamStatisticsMixin, nudgeFn: (nudge: TimestampProgramNudge) => SourceMessage, onEof: (() => void) | undefined, grpcStartFn: () => grpc.ClientDuplexStream<SourceMessage, TsInputEvent>);
+    /**
+     * @public
+     * Applies a gradual nudge to the outgoing stream timestamps by the specified number of milliseconds
+     * */
+    nudge(programNumber: number, nudge: number): void;
+}
+
+declare enum TsInputType {
+    TsFile = 0,
+    Srt = 1,
+    Udp = 2,
+    M3u8 = 3
+}
+
+/** @public */
+export declare type TsPlaylist = MediaPlaylistPart[];
+
+/** @public */
+export declare type TsPlaylistAdditions = [MediaPlaylistPart[], Date];
+
+/**
+ * @public
+ * see: {@link NorskInput.udpTs}
+ */
+export declare class UdpTsInputNode extends TsCommonInputNode<UdpTsInputMessage, UdpTsInputNode> {
+}
+
+/**
+ * @public
+ * Settings for a UDP Transport Stream input
+ * see: {@link NorskInput.udpTs}
+ * */
+export declare interface UdpTsInputSettings extends RemoteInputSettings<UdpTsInputNode> {
+    interface?: string;
+    timeout?: number;
+    /** Whether to expect the input TS to be encapsulated in RTP via RFC 2250 (default: false) */
+    rtpDecapsulate?: boolean;
+}
+
+/**
+ * @public
+ * see: {@link NorskOutput.udpTs}
+ */
+export declare class UdpTsOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+}
+
+/**
+ * @public
+ * The settings for an output Transport Stream over UDP
+ * see: {@link NorskOutput.udpTs}
+ */
+export declare interface UdpTsOutputSettings extends SinkNodeSettings<UdpTsOutputNode>, StreamStatisticsMixin {
+    /**
+     * The IP address to publish to
+     * This can be multicast, unicast or broadcast
+     */
+    destinationIp: string;
+    /**
+     * The interface to bind to for publishing
+     * This can be 'any', 'loopback' or any named interface on the machine
+     * Note: If running inside docker this may be different to expected
+     */
+    interface: string;
+    /** The port to send to */
+    port: number;
+    /** Jitter buffer delay in milliseconds */
+    bufferDelayMs?: number;
+    /** A/V delay in milliseconds - to allow inclusion of subtitles, metadata and other ancillary data. May be set to 0 if these are not present to reduce latency */
+    avDelayMs?: number;
+    /** Whether to encapsulate in RTP via RFC 2250 (default: false) */
+    rtpEncapsulate?: boolean;
+}
+
+/**
+ * @public
+ * An update request for credentials on a CMAF output
+ */
+export declare interface UpdateCredentials {
+    /**
+     * The id of the destination that is to be updated (see {@link HlsPushDestinationSettings.id})
+     */
+    destinationId: string;
+    /**
+     * the new credentials to be used by the destination
+     */
+    awsCredentials: AwsCredentials;
+}
+
+/** @public */
+export declare type VancPayloadFormat = "other" | "afd_bar" | "pan_scan" | "scte104" | "dvb_scte_vbi" | "op47_sdp" | "op47_vanc_multipacket" | "ancillary_time_code" | "eia_708" | "eia_608";
+
+/** @public */
+export declare interface VancType2AncillaryId {
+    did: number;
+    sdid: number;
+}
+
+export { Version }
+
+/**
+ * @public
+ * see: {@link NorskTransform.videoCompose}
+ */
+export declare class VideoComposeNode<Pins extends string> extends ProcessorMediaNode<Pins> {
+    /**
+     * @public
+     * Updates the config used for a video compose operation
+     * If transitions are specified, animations will be provided, otherwise
+     * the change will be immediate
+     *
+     * Note: This is not a 'cheap' operation and care should be taken not to
+     * do this too often (more than once a second for example!)
+     */
+    updateConfig(settings: VideoComposeSettingsUpdate<Pins>): void;
+}
+
+/** @public */
+export declare interface VideoComposeSettings<Pins extends string> extends ProcessorNodeSettings<VideoComposeNode<Pins>> {
+    /**
+     * Required. Stream key of the reference stream. This is the video stream
+     * which defines the output frame timing, which will typically be part of the
+     * composition, e.g. the main picture in the case of a simple
+     * overlay/picture-in-picture, or the top left quadrant of a 4-way split
+     * screen.
+     */
+    referenceStream: Pins;
+    /** The parts (images/overlays) to include in the composition */
+    parts: readonly ComposePart<Pins>[];
+    /**
+     * Optionally supply a fallback reference resolution. This allows description of the
+     * composition in a desired coordinate system, e.g. a resolution of 100x100
+     * can be specified to allow the source and destination areas to be described
+     * in percentage terms, or a notional resolution can be used that is
+     * independant of the source resolutions that may be provided.
+     *
+     * if set here, this reference resolution will be applied to
+     * any parts that do not have their own reference resolution specified
+     *
+     * If not provided the source and destination rectangles are in terms of the
+     * source and output resolutions respectively.
+     */
+    referenceResolution?: Resolution;
+    /** The resolution of the output video */
+    outputResolution: Resolution;
+    /**
+     * Output pixel format to use. If not specified, this will be chosen
+     * automatically based on the sources present in the initial composition
+     */
+    outputPixelFormat?: PixelFormat;
+    /**
+     * Behaviour in the case of a missing stream used in an active composition
+     * part. Note that this does not apply to the reference stream, but to every
+     * part which does not use the reference stream, whether at startup or on
+     * context change.
+     *
+     * Missing means not present in the context or never having sent a frame.
+     */
+    missingStreamBehaviour?: ComposeMissingStreamBehaviour;
+    /**
+     * Optionally attempt to perform the compose operation on hardware
+     */
+    hardwareAcceleration?: ComposeHardwareAcceleration;
+    /**
+     * Called when the transitions specified in the last config update have
+     * completed (in the case of multiple parts with specified transitions of
+     * different duration, this means that the last remaining transitions have
+     * completed
+     */
+    onTransitionComplete?: () => void;
+}
+
+/**
+ * @public
+ * An update operation for a VideoCompose operation
+ * see: {@link VideoComposeNode.updateConfig}
+ * */
+export declare interface VideoComposeSettingsUpdate<Pins extends string> {
+    /** Update the parts (images/overlays) to include in the composition */
+    parts: readonly ComposePart<Pins>[];
+}
+
+/**
+ * @public
+ * see: {@link NorskTransform.videoEncode}
+ */
+export declare class VideoEncodeNode extends AutoProcessorMediaNode<"video"> {
+}
+
+/**
+ * @public
+ * A single rung in a video encode ladder
+ * see: {@link NorskTransform.videoEncode}
+ * */
+export declare interface VideoEncodeRung {
+    /** The name of this rung, this should be unique across the ladder
+     * and will end up in the renditionName of the outgoing StreamKey
+     */
+    name: string;
+    /** The width of the outgoing video resolution */
+    width: number;
+    /** The height of the outgoing video resolution */
+    height: number;
+    /**
+     * Optionally change the frameRate for this rendition
+     * This can be useful if the input is 50FPS for example and some
+     * lower rungs need to be 25fps
+     *
+     * Note: If you wish to apply the same frame rate across all rungs, it is
+     * more efficient to use a single {@link VideoTransformNode} before the ladder
+     * created with {@link NorskTransform.videoTransform} and leave this value undefined
+     * */
+    frameRate?: FrameRate;
+    /**
+     * Specifies the input video's Sample Aspect Ratio (SAR) to be used by the
+     * encoder in width:height
+     */
+    sar?: SampleAspectRatio;
+    /**
+     * The codec (and detailed configuration) to use for the encoding operation.
+     *
+     * Note: Nvidia, Logan/Quadra, and Xilinx require Nvidia, Logan/Quadra and Xilinx hardware to be set up and
+     * made available to Norsk
+     *
+     * A ladder can use several different codecs across its various rungs and the
+     * VideoEncode node will attempt to build a pipeline that uses the hardware efficently
+     */
+    codec: X264Codec | X265Codec | NvidiaH264 | NvidiaHevc | LoganH264 | LoganHevc | QuadraH264 | QuadraHevc | XilinxH264 | XilinxHevc;
+}
+
+/**
+ * @public
+ * Settings for a VideoEncode operation
+ * see: {@link NorskTransform.videoEncode}
+ * */
+export declare interface VideoEncodeSettings extends ProcessorNodeSettings<VideoEncodeNode> {
+    rungs: readonly VideoEncodeRung[];
+}
+
+/**
+ * @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;
+    frameRate?: FrameRate_2;
+}
+
+/**
+ * @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
+ * see: {@link NorskInput.audioSignal}
+ */
+export declare class VideoTestcardGeneratorNode extends SourceMediaNode {
+}
+
+/**
+ * @public
+ * Settings for an Video Testcard Generator
+ * see: {@link NorskInput.videoTestcard}
+ * */
+export declare interface VideoTestcardGeneratorSettings extends SourceNodeSettings<VideoTestcardGeneratorNode> {
+    /** The source name to set in the stream key of the outgoing stream */
+    sourceName: string;
+    /** The number of frames to send before shutting down */
+    numberOfFrames?: number;
+    /** Resolution of the test card stream **/
+    resolution: {
+        width: number;
+        height: number;
+    };
+    /** Framerate of the produced video stream **/
+    frameRate: {
+        frames: number;
+        seconds: number;
+    };
+    pattern: Pattern;
+}
+
+/** @public */
+export declare function videoToPin<Pins extends string>(pin: Pins): (streams: StreamMetadata[]) => PinToKey<Pins>;
+
+/**
+ * @public
+ * see: {@link NorskTransform.videoTransform}
+ */
+export declare class VideoTransformNode extends AutoProcessorMediaNode<"video"> {
+}
+
+/**
+ * @public
+ * Settings for a Video Transform node
+ * see: {@link NorskTransform.videoTransform}
+ * */
+export declare interface VideoTransformSettings extends ProcessorNodeSettings<VideoTransformNode> {
+    /** An optional resolution to rescale this single stream to */
+    resolution?: Resolution;
+    /** An optional framerate to resample this single stream to */
+    frameRate?: FrameRate;
+    /** An optional SAR to set on the outgoing stream
+     * Note: You can set this and only this if the SAR on your incoming stream is incorrect
+     * for example (An often-seen problem with sources)
+     * */
+    sar?: SampleAspectRatio;
+}
+
+/**
+ * @public
+ * see: {@link NorskDuplex.webRtcBrowser}
+ */
+export declare class WebRTCBrowserNode extends AutoProcessorMediaNode<"audio" | "video"> {
+    /** @public The URL of the local player */
+    playerUrl: string;
+}
+
+/**
+ * @public
+ * Settings for a WebRTC browser session
+ * see: {@link NorskDuplex.webRtcBrowser}
+ * */
+export declare interface WebRTCBrowserSettings extends ProcessorNodeSettings<WebRTCBrowserNode>, StreamStatisticsMixin {
+    iceServers?: IceServerSettings[];
+    reportedIceServers?: IceServerSettings[];
+    hostIps?: string[];
+    serverReflexiveIps?: string[];
+    /** Jitter buffer delay in milliseconds */
+    bufferDelayMs?: number;
+}
+
+/**
+ * @public
+ * see: {@link NorskOutput.whep}
+ */
+export declare class WhepOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+    /** @public The URL of the local player */
+    playerUrl: string;
+    /** @public The URL of the WHEP endpoint */
+    endpointUrl: string;
+}
+
+/**
+ * @public
+ * The settings for a WebRTC WHEP Output
+ * see {@link NorskOutput.whep}
+ */
+export declare interface WhepOutputSettings extends SinkNodeSettings<WhepOutputNode>, StreamStatisticsMixin {
+    iceServers?: IceServerSettings[];
+    reportedIceServers?: IceServerSettings[];
+    hostIps?: string[];
+    serverReflexiveIps?: string[];
+    /** Jitter buffer delay in milliseconds */
+    bufferDelayMs?: number;
+}
+
+/**
+ * @public
+ * see: {@link NorskInput.whip}
+ */
+export declare class WhipInputNode extends SourceMediaNode {
+    /** @public The URL of the local test client */
+    clientUrl: string;
+    /** @public The URL of the WHIP endpoint */
+    endpointUrl: string;
+    /**
+     * @public
+     * Applies a gradual nudge to the outgoing stream timestamps by the specified number of milliseconds
+     * */
+    nudge(sourceName: string, programNumber: number, nudge: number): void;
+}
+
+/** @public */
+export declare interface WhipInputSettings extends InputSettings<WhipInputNode>, StreamStatisticsMixin {
+    /**  List of ice servers to use as part of session negotiation */
+    iceServers?: IceServerSettings[];
+    /**  Internal addresses for the ice servers (defaults to iceServers) */
+    reportedIceServers?: IceServerSettings[];
+    /**
+     * List of IPs to advertise as your host address - useful e.g. when on a cloud server
+     * so that the public rather than private IP is used.
+     */
+    hostIps?: string[];
+    /**
+     * Similar to hostIps, but a list of server reflexive candidates so that ICE negotiations can be
+     * sped up
+     */
+    serverReflexiveIps?: string[];
+}
+
+/**
+ * @public
+ * see: {@link NorskOutput.whip}
+ */
+export declare class WhipOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
+}
+
+/**
+ * @public
+ * The settings for a WebRTC Whip Output
+ * see {@link NorskOutput.whip}
+ */
+export declare interface WhipOutputSettings extends SinkNodeSettings<WhipOutputNode>, StreamStatisticsMixin {
+    /**
+     * The URI to make the initial publish request to (as per the WHIP protocol)
+     */
+    uri: string;
+    /** The auth header to supply (for example: 'Bearer: mybearertoken') */
+    authHeader: string;
+    /** Jitter buffer delay in milliseconds */
+    bufferDelayMs?: number;
+}
+
+declare type WhisperSamplingStrategy = {
+    strategy: 'greedy';
+    bestOf?: number;
+} | {
+    strategy: "beam_search";
+    beam_size?: number;
+};
+
+/** @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
+ * See the X264 Docs for a description of this value
+ * */
+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
+ *
+ * See the X264 Docs for a further description of this value
+ */
+export declare type X264NalHrd = "none" | "vbr" | "cbr";
+
+/**
+ * @public
+ * See the X264 Docs for a description of this value
+ * */
+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
+ * See the X264 Docs for a description of this value
+ * */
+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;
+    tier?: X265Tier;
+    /**
+     * 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
+ * See the X265 Docs for a description of this value
+ * */
+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
+ * See the X265 Docs for a description of this value
+ * */
+export declare type X265Preset = "ultrafast" | "superfast" | "veryfast" | "faster" | "fast" | "medium" | "slow" | "slower" | "veryslow" | "placebo";
+
+/**
+ * @public
+ * See the X265 Docs for a description of this value
+ * */
+export declare type X265Profile = "main" | "main10" | "main444_8" | "main422_10" | "main444_10";
+
+/**
+ * @public
+ * See the X265 Docs for a description of this value
+ * */
+export declare type X265Tier = "main" | "high";
+
+/**
+ * @public
+ * See the X265 Docs for a description of this value
+ * */
+export declare type X265Tune = "psnr" | "ssim" | "grain" | "zerolatency" | "fastdecode" | "animation";
+
+/**
+ * @public
+ * Settings for a H264 Encode using Xilinx hardware
+ * A detailed description of these params can be found
+ * on the Xilinx Encoder Documentation
+ *
+ * These fields have deliberately been written to maintain the same semantics as the
+ * Xilinx documentation where possible.
+ *
+ * If left undefined, all will default to Xilinx's own defaults
+ * */
+export declare interface XilinxH264 {
+    type: "xilinx-h264";
+    profile?: XilinxH264Profile;
+    level?: XilinxH264Level;
+    rateControl?: XilinxRateControl;
+    lookaheadDepth?: number;
+    idrPeriod?: number;
+    bframes?: number;
+    gopSize?: number;
+    minQp?: number;
+    maxQp?: number;
+}
+
+/** @public */
+export declare type XilinxH264Level = 1 | 2 | 2.1 | 3 | 3.1 | 4 | 4.1 | 5 | 5.1 | 5.2 | 6 | 6.1 | 6.2;
+
+/** @public */
+export declare type XilinxH264Profile = "baseline" | "main" | "extended" | "high" | "high10";
+
+/**
+ * @public
+ * Settings for a HEVC Encode using Xilinx hardware
+ * A detailed description of these params can be found
+ * on the Xilinx Encoder Documentation
+ *
+ * These fields have deliberately been written to maintain the same semantics as the
+ * Xilinx documentation where possible.
+ *
+ * If left undefined, all will default to Xilinx's own defaults
+ * */
+export declare interface XilinxHevc {
+    type: "xilinx-hevc";
+    profile?: XilinxHevcProfile;
+    level?: XilinxHevcLevel;
+    tier?: XilinxHevcTier;
+}
+
+/** @public */
+export declare type XilinxHevcLevel = 1 | 2 | 2.1 | 3 | 3.1 | 4 | 4.1 | 5 | 5.1 | 5.2 | 6 | 6.1 | 6.2;
+
+/** @public */
+export declare type XilinxHevcProfile = "main" | "main10";
+
+/** @public */
+export declare type XilinxHevcTier = "main" | "high";
+
+/** @public */
+export declare interface XilinxRateControl {
+    value: number;
+    mode: "constQp" | "cbr" | "vbr" | "lowLatency";
+}
+
+export { }