@norskvideo/norsk-sdk 1.0.351 → 1.0.354

package/dist/norsk-sdk.d.ts

@@ -22,7 +22,6 @@ 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';
@@ -31,6 +30,7 @@ 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 { VideoTransformConfiguration } from '@norskvideo/norsk-api/lib/media_pb';
 import { Wave } from '@norskvideo/norsk-api/lib/media_pb';
 import { Writable } from 'stream';
 
@@ -59,11 +59,11 @@ export declare interface AdMarker {
 }
 
 export declare class AncillaryNode extends AutoProcessorMediaNode<"ancillary"> {
-    sendScte35(key: StreamKey, info: Scte35SpliceInfoSection_2): void;
+    sendScte35(key: StreamKey, info: Scte35SpliceInfoSection): void;
 }
 
 export declare interface AncillarySettings extends ProcessorNodeSettings<AncillaryNode> {
-    onScte35?: (stream: StreamKey, message: Scte35SpliceInfoSection_2) => void;
+    onScte35?: (stream: StreamKey, message: Scte35SpliceInfoSection) => void;
     onSmpte2038?: (stream: StreamKey, message: Smpte2038Message) => void;
 }
 
@@ -440,11 +440,18 @@ export declare class AudioTranscribeWhisperNode extends AutoProcessorMediaNode<"
 
 /**
  * @public
- * Settings for an Audio Transcribe operation using Whisper sdk
+ * Settings for an Audio Transcribe operation using Whisper sdk (whisper-cpp)
  * see: {@link NorskTransform.audioTranscribeWhisper}
  * */
 export declare interface AudioTranscribeWhisperSettings extends ProcessorNodeSettings<AudioTranscribeWhisperNode> {
     outputStreamId: number;
+    /** The duration of audio that is accumulated before performing one transcription step. Decreasing this
+     * value will decrease latency but also decrease performance. Visualiser metrics are available to monitor the
+     * duration of each "step" operation, if this is not clearly faster than the audio duration real-time output will not be
+     * attained and the workflow will back up.
+     *
+     * Default 3000ms.
+     */
     stepMs?: number;
     lengthMs?: number;
     keepMs?: number;
@@ -452,12 +459,38 @@ export declare interface AudioTranscribeWhisperSettings extends ProcessorNodeSet
     speedUp?: boolean;
     noFallback?: boolean;
     numThreads?: number;
+    /**
+     * Use GPU if available. In the cases where GPU is available, it may not necessarily increase performance, but instead opt
+     * to move load from CPU to GPU.
+     */
     useGpu?: boolean;
+    /**
+     * Language setting for the Whisper model. Leave unset to auto-detect (with a multi-language model)
+     */
     language?: string;
+    /**
+     * The file name of the GGML-format whisper model.
+     *
+     * Information: https://github.com/ggerganov/whisper.cpp/blob/master/models/README.md
+     *
+     * Model downloads: https://huggingface.co/ggerganov/whisper.cpp/tree/main
+     */
     model: string;
+    /**
+     * Whether to translate a non-English input to English, or leave the foreign-language transcription in the source language.
+     */
     translate?: boolean;
+    /**
+     * Enable tiny-diarize if supported in the given model
+     */
     tinyDiarize?: boolean;
+    /**
+     * Initial prompt to prime the model - this is in addition to prompting based on past transcription history.
+     */
     initialPrompt?: string;
+    /**
+     * Whether to suppress non-speech tokens
+     */
     suppressNonSpeechTokens?: boolean;
     samplingStrategy?: WhisperSamplingStrategy;
 }
@@ -539,6 +572,22 @@ export declare interface AwsS3PushDestinationSettings {
      * in order to generate an accurate playlist
      */
     retentionPeriodSeconds: number;
+    /**
+     * In the absence of a HLS_SKIP query parameter, how many segments should be served in a playlist
+     * this effectively controls how far back in time a player can seek from first load (as long as the data exists)
+     */
+    defaultSegmentCount?: number;
+    /**
+     Server control directive, informs the client how far back in the stream (in seconds) it should attempt to play
+     this should take into account the end to end latency from source capture, to the segment and playlist being published
+     */
+    holdBackSeconds?: number;
+    /**
+     Server control directive, informs the client how far back in the stream (in seconds) it should attempt to play
+     when using the lower latency parts
+     this should take into account the end to end latency from source capture, to the part and playlist being published
+     */
+    partHoldBackSeconds?: number;
 }
 
 /**
@@ -795,6 +844,8 @@ export declare type CmafDestinationSettings = HlsPushDestinationSettings | AwsS3
 export declare class CmafMultiVariantOutputNode extends CmafNodeBase<CmafMultiVariantMessage, "video" | "audio" | "subtitle", CmafMultiVariantOutputNode> {
     /** @public The URL of the file based multi variant playlist */
     url: string;
+    /** @public The URL of the file based DASH manifest */
+    dashUrl: string;
     /**
      * @public
      * Updates the credentials for a specific destination within this output by id
@@ -848,7 +899,6 @@ declare class CmafNodeBase<ClientMessage, Pins extends string, T extends MediaNo
 }
 
 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
@@ -874,18 +924,6 @@ export declare interface CmafOutputSettings extends SinkNodeSettings<CmafAudioOu
      * 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.
      */
@@ -906,10 +944,6 @@ export declare interface CmafOutputSettings extends SinkNodeSettings<CmafAudioOu
      * 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;
 }
 
 /**
@@ -955,18 +989,6 @@ export declare interface CmafWebVttOutputSettings extends SinkNodeSettings<CmafW
      * 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
      */
@@ -975,10 +997,6 @@ export declare interface CmafWebVttOutputSettings extends SinkNodeSettings<CmafW
      * 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 */
@@ -1148,6 +1166,11 @@ export declare type DeckLinkVideoIOSupport = "capture" | "playback";
 /** @public */
 export declare type DeferredVideoComposeSettings<Pins extends string> = (streams: StreamMetadata[]) => VideoComposeSettings<Pins> | undefined;
 
+export declare type DeinterlaceSettings = {
+    type: 'software';
+    algorithm: 'bwdif' | 'kerndeint' | 'nnedi' | 'w3fdif' | 'yadif';
+};
+
 /** @public */
 export declare type DestinationId = string;
 
@@ -1251,6 +1274,8 @@ export declare class FileMp4InputNode extends SourceMediaNode {
      * */
     nudge(nudge: number): void;
     updateSettings(settings: FileMp4InputSettingsUpdate): void;
+    pause(): void;
+    play(): void;
 }
 
 /**
@@ -1269,6 +1294,8 @@ export declare interface FileMp4InputSettings extends SourceNodeSettings<FileMp4
     onInfo?: (info: FileMp4Info) => void;
     /** Whether to loop back to the start of the file after reaching the end (default false) */
     loop?: boolean;
+    /** Whether to start paused or already playing (default: playing) */
+    start?: 'playing' | 'paused';
 }
 
 export declare interface FileMp4InputSettingsUpdate {
@@ -1325,12 +1352,16 @@ export declare interface FileMp4OutputSettings extends SinkNodeSettings<FileMp4O
  */
 export declare class FileTsInputNode extends TsCommonInputNode<FileTsInputMessage, FileTsInputNode> {
     updateSettings(settings: FileTsInputSettingsUpdate): void;
+    pause(): void;
+    play(): 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;
+    /** Whether to start paused or already playing (default: playing) */
+    start?: 'playing' | 'paused';
 }
 
 /** @public */
@@ -1407,7 +1438,7 @@ export declare type FrameStoreExpiry = FrameStoreExpireBySize | FrameStoreExpire
 
 /**
  * @public
- * see: {@link NorskInput.frameStorePlayer}
+ * see: {@link NorskInput.frameStore}
  */
 export declare class FrameStorePlayerNode extends SourceMediaNode {
 }
@@ -1415,7 +1446,7 @@ export declare class FrameStorePlayerNode extends SourceMediaNode {
 /**
  * @public
  * Settings for Frame Store playback
- * see: {@link NorskInput.frameStorePlayer}
+ * see: {@link NorskInput.frameStore}
  */
 export declare interface FrameStorePlayerSettings extends InputSettings<FrameStorePlayerNode>, StreamStatisticsMixin {
     /**
@@ -1440,7 +1471,7 @@ export declare interface FrameStorePlayerSettings extends InputSettings<FrameSto
 
 /**
  * @public
- * see: {@link NorskOutput.frameStoreRecording}
+ * see: {@link NorskOutput.frameStore}
  */
 export declare class FrameStoreRecorderNode extends AutoSinkMediaNode<"audio" | "video"> {
     makeCut(request: FrameStoreCutRequest): void;
@@ -1449,7 +1480,7 @@ export declare class FrameStoreRecorderNode extends AutoSinkMediaNode<"audio" |
 /**
  * @public
  * Settings to configure a frame store recorder
- * see {@link NorskOutput.frameStoreRecorder}
+ * see {@link NorskOutput.frameStore}
  */
 export declare interface FrameStoreRecorderSettings extends SinkNodeSettings<FrameStoreRecorderNode>, StreamStatisticsMixin {
     /**
@@ -1547,6 +1578,22 @@ export declare interface HlsPushDestinationSettings {
      * in order to generate an accurate playlist
      */
     retentionPeriodSeconds: number;
+    /**
+     * In the absence of a HLS_SKIP query parameter, how many segments should be served in a playlist
+     * this effectively controls how far back in time a player can seek from first load (as long as the data exists)
+     */
+    defaultSegmentCount?: number;
+    /**
+     Server control directive, informs the client how far back in the stream (in seconds) it should attempt to play
+     this should take into account the end to end latency from source capture, to the segment and playlist being published
+     */
+    holdBackSeconds?: number;
+    /**
+     Server control directive, informs the client how far back in the stream (in seconds) it should attempt to play
+     when using the lower latency parts
+     this should take into account the end to end latency from source capture, to the part and playlist being published
+     */
+    partHoldBackSeconds?: number;
 }
 
 /** @public */
@@ -1582,18 +1629,6 @@ export declare interface HlsTsAudioOutputSettings extends SinkNodeSettings<HlsTs
      * 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
      */
@@ -1610,10 +1645,6 @@ export declare interface HlsTsAudioOutputSettings extends SinkNodeSettings<HlsTs
      * Audio bitrate for the {@link NorskOutput.hlsTsMultiVariant} playlist
      */
     bitrate?: number;
-    /**
-     * The maximum number of segments to display in a single generated playlist
-     */
-    maximumPlaylistSegments?: number;
 }
 
 /**
@@ -1635,18 +1666,6 @@ export declare interface HlsTsCombinedPushOutputSettings extends SinkNodeSetting
      * 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
      */
@@ -1733,18 +1752,6 @@ export declare interface HlsTsVideoOutputSettings extends SinkNodeSettings<HlsTs
      * 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
      */
@@ -1761,10 +1768,6 @@ export declare interface HlsTsVideoOutputSettings extends SinkNodeSettings<HlsTs
      * 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 */
@@ -1875,6 +1878,22 @@ export declare interface LocalPullDestinationSettings {
      * and informs the local web server how long to retain those segments
      */
     retentionPeriodSeconds: number;
+    /**
+     * In the absence of a HLS_SKIP query parameter, how many segments should be served in a playlist
+     * this effectively controls how far back in time a player can seek from first load (as long as the data exists)
+     */
+    defaultSegmentCount?: number;
+    /**
+     Server control directive, informs the client how far back in the stream (in seconds) it should attempt to play
+     this should take into account the end to end latency from source capture, to the segment and playlist being published
+     */
+    holdBackSeconds?: number;
+    /**
+     Server control directive, informs the client how far back in the stream (in seconds) it should attempt to play
+     when using the lower latency parts
+     this should take into account the end to end latency from source capture, to the part and playlist being published
+     */
+    partHoldBackSeconds?: number;
 }
 
 /** @public */
@@ -2024,17 +2043,17 @@ export declare function mkSine(freq: number): Wave;
 
 /**
  * @public
- * see: {@link NorskOutput.moqEgest}
+ * see: {@link NorskOutput.moq}
  */
-export declare class MoqEgestNode extends AutoSinkMediaNode<"audio" | "video"> {
+export declare class MoqOutputNode extends AutoSinkMediaNode<"audio" | "video"> {
 }
 
 /**
  * @public
  * Settings to configure a Moq Egest
- * see {@link NorskOutput.moqEgest}
+ * see {@link NorskOutput.moq}
  */
-export declare interface MoqEgestSettings extends SinkNodeSettings<MoqEgestNode>, StreamStatisticsMixin {
+export declare interface MoqOutputSettings extends SinkNodeSettings<MoqOutputNode>, StreamStatisticsMixin {
 }
 
 /** @public */
@@ -2278,7 +2297,7 @@ export declare interface NorskInput {
     /**
      * Playback from an existing Frame Store recording
      */
-    frameStorePlayer(settings: FrameStorePlayerSettings): Promise<FrameStorePlayerNode>;
+    frameStore(settings: FrameStorePlayerSettings): Promise<FrameStorePlayerNode>;
 }
 
 /**
@@ -2422,13 +2441,13 @@ export declare interface NorskOutput {
      *
      * @param settings - Configuration for the frame store recorder
      */
-    frameStoreRecording(settings: FrameStoreRecorderSettings): Promise<FrameStoreRecorderNode>;
+    frameStore(settings: FrameStoreRecorderSettings): Promise<FrameStoreRecorderNode>;
     /**
      * Create a Moq Egest
      *
      * @param settings - Configuration for the egest
      */
-    moqEgest(settings: MoqEgestSettings): Promise<MoqEgestNode>;
+    moq(settings: MoqOutputSettings): Promise<MoqOutputNode>;
 }
 
 /** @public */
@@ -2495,6 +2514,14 @@ export declare interface NorskTransform {
      * @param settings - Encode ladder settings
      */
     videoEncode(settings: VideoEncodeSettings): Promise<VideoEncodeNode>;
+    /**
+     * Decode a video stream to a specific type of 'raw' format
+     * this isn't usually needed because decode will happen automatically for nodes that need raw data
+     * however if we definitely want a hardware decode and we're creating nodes that accept inMemory raw, we can use this node
+     * to ensure that the hardware decode takes place
+     * @param settings - Decode settings
+     */
+    videoDecode(settings: VideoDecodeSettings): Promise<VideoDecodeNode>;
     /**
      * Transform a single video stream (rescale, frame rate, etc)
      * @param settings - Transform settings
@@ -2529,7 +2556,10 @@ export declare interface NorskTransform {
     audioTranscribeAzure(settings: AudioTranscribeAzureSettings): Promise<AudioTranscribeAzureNode>;
     /**
      * Create a Media Node performing transcription into subtitles using the
-     * Whisper speech recognition model.
+     * Whisper speech recognition model via the whisper-cpp SDK.
+     *
+     * For reference on general concepts https://github.com/ggerganov/whisper.cpp - many settings are directly settings on the
+     * underlying library and can be evaluted via the CLI tool there also.
      * @param settings - Settings and credentials for Whisper transcribe
      */
     audioTranscribeWhisper(settings: AudioTranscribeWhisperSettings): Promise<AudioTranscribeWhisperNode>;
@@ -2571,6 +2601,10 @@ export declare interface NorskTransform {
      * bitrate.
      */
     audioEncode(settings: AudioEncodeSettings): Promise<AudioEncodeNode>;
+    /**
+     * Translate subtitles using the AWS Translate service
+     */
+    subtitleTranslateAws(settings: SubtitleTranslateAwsSettings): Promise<SubtitleTranslateAwsNode>;
     /**
      * A node to nudge the timestamps on a stream, which affects how it syncs
      * with other streams. Useful for correcting for drift between different
@@ -2772,13 +2806,13 @@ export declare type NvidiaPreset = "p1" | "p2" | "p3" | "p4" | "p5" | "p6" | "p7
 export declare interface NvidiaRateControl {
     /** the mode to use for this rate control operation */
     mode: NvidiaRateControlMode;
-    /** The average bitrate of this encode */
+    /** The average bitrate of this encode (bits/sec) */
     averageBitrate: number;
-    /** The max bitrate of this encode */
+    /** The max bitrate of this encode (bits/sec) */
     maxBitrate?: number;
-    /** The vbv buffer size used for this encode */
+    /** The vbv buffer size used for this encode (bits) */
     vbvBufferSize?: number;
-    /** The vbv initial delay used for this encode */
+    /** The vbv initial delay used for this encode (bits) */
     vbvInitialDelay?: number;
     /** Enable lookahead or not:
      * Note: enabling lookahead will introduce scene cuts unless this is specifically disabled
@@ -2871,12 +2905,6 @@ export declare type PlaylistOnChangeFn<ClientMessage> = {
     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
@@ -3745,6 +3773,26 @@ export declare interface SrtInputSettings extends RemoteInputSettings<SrtInputNo
      * Stream ID to set on the socket when acting in caller mode
      */
     streamId?: string;
+    /**
+     * The latency value in the receiving direction of the socket (SRTO_RCVLATENCY)
+     */
+    receiveLatency?: number;
+    /**
+     * The latency value provided by the sender side as a minimum value for the receiver (SRTO_PEERLATENCY)
+     */
+    peerLatency?: number;
+    /**
+     * Input bandwidth (SRTO_INPUTBW)
+     */
+    inputBandwidth?: number;
+    /**
+     * Overhead bandwidth (SRTO_OHEADBW)
+     */
+    overheadBandwidth?: number;
+    /**
+     * Max bandwidth (SRTO_MAXBW)
+     */
+    maxBandwidth?: number;
     /**
      * On connect callback, notifying that a new caller has connected (in listener mode) and set the source name accordingly
      * @eventProperty
@@ -3797,6 +3845,26 @@ export declare interface SrtOutputSettings extends SinkNodeSettings<SrtOutputNod
      * Stream ID to set on the socket when acting in caller mode
      */
     streamId?: string;
+    /**
+     * The latency value in the receiving direction of the socket (SRTO_RCVLATENCY)
+     */
+    receiveLatency?: number;
+    /**
+     * The latency value provided by the sender side as a minimum value for the receiver (SRTO_PEERLATENCY)
+     */
+    peerLatency?: number;
+    /**
+     * Input bandwidth (SRTO_INPUTBW)
+     */
+    inputBandwidth?: number;
+    /**
+     * Overhead bandwidth (SRTO_OHEADBW)
+     */
+    overheadBandwidth?: number;
+    /**
+     * Max bandwidth (SRTO_MAXBW)
+     */
+    maxBandwidth?: number;
     /**
      * The mode to act in (see {@link SrtMode})
      */
@@ -3976,6 +4044,12 @@ export declare interface StreamMetadataOverrideSettingsUpdate {
     subtitles?: {
         /** Override the language metadata of a subtitles stream, or `""` to clear. RFC 5646 language tag. */
         language?: string;
+        /** Override the property of whether a subtitles string is the default/primary rendition or not */
+        default?: boolean;
+    };
+    playlist?: {
+        /** Override the name of a playlist stream, or `""` to clear. Free form text. */
+        name?: string;
     };
 }
 
@@ -4249,6 +4323,31 @@ export declare interface SubtitleStreamMetadata {
  */
 export declare function subtitleStreams(streams: readonly StreamMetadata[]): StreamMetadata[];
 
+/**
+ * @public
+ * see: {@link NorskTransform.subtitleTranslateAws}
+ */
+export declare class SubtitleTranslateAwsNode extends AutoProcessorMediaNode<"audio"> {
+}
+
+/**
+ * @public
+ * Settings for an Audio Transcribe operation using AWS
+ * see: {@link NorskTransform.subtitleTranslateAws}
+ * */
+export declare interface SubtitleTranslateAwsSettings extends ProcessorNodeSettings<SubtitleTranslateAwsNode> {
+    /** Source language code/tag, e.g. de or fr-CA (omit to use the source subtitle language / AWS automatic detection) */
+    sourceLanguage?: string;
+    /** Target language code/tag, e.g. en or es-MX */
+    targetLanguage: string;
+    /** Enable brevity option */
+    brevity?: boolean;
+    /** Enable profanity masking */
+    maskProfanity?: boolean;
+}
+
+export declare function toDeinterlaceSettings(settings: DeinterlaceSettings): VideoTransformConfiguration["deinterlace"];
+
 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>);
     /**
@@ -4432,6 +4531,22 @@ export declare interface VideoComposeSettingsUpdate<Pins extends string> {
     parts: readonly ComposePart<Pins>[];
 }
 
+/**
+ * @public
+ * see: {@link NorskTransform.videoDecode}
+ */
+export declare class VideoDecodeNode extends AutoProcessorMediaNode<"video"> {
+}
+
+/**
+ * @public
+ * Settings for a VideoDecode operation
+ * see: {@link NorskTransform.videoDecode}
+ * */
+export declare interface VideoDecodeSettings extends ProcessorNodeSettings<VideoDecodeNode> {
+    decoder: 'software' | 'nvidia' | 'quadra' | 'logan' | 'xilinx';
+}
+
 /**
  * @public
  * see: {@link NorskTransform.videoEncode}
@@ -4563,6 +4678,8 @@ export declare interface VideoTransformSettings extends ProcessorNodeSettings<Vi
     resolution?: Resolution;
     /** An optional framerate to resample this single stream to */
     frameRate?: FrameRate;
+    /** An optional de-interlace algorithm to apply on this stream */
+    deinterlace?: DeinterlaceSettings;
     /** 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)
@@ -4737,7 +4854,7 @@ export declare interface X264Codec {
      */
     cabac?: boolean;
     /**
-     * Sets the maximum rate the VBV buffer should be assumed to refill at
+     * Sets the maximum rate the VBV buffer should be assumed to refill at (kbit/s)
      */
     vbvMaxRate?: number;
     /**
@@ -4839,7 +4956,7 @@ export declare interface X265Codec {
      */
     frameReference?: number;
     /**
-     * Sets the maximum rate the VBV buffer should be assumed to refill at
+     * Sets the maximum rate the VBV buffer should be assumed to refill at (kbit/s)
      */
     vbvMaxRate?: number;
     /**

package/lib/src/media_nodes/common.js

@@ -123,6 +123,10 @@ class SourceMediaNode extends MediaNodeState {
             }
             ;
             let index = pending.pendingSubscribes.indexOf(subscriber);
+            if (index === -1) {
+                (0, utils_1.errorlog)("No pending subscriber %s found for ref %s on %s (%d), something went horribly wrong", subscriber.id, context.blockingCallRef, this.id, pending.pendingSubscribes.length);
+                return;
+            }
             pending.pendingSubscribes.splice(index, 1);
             this.maybeAckPendingContext(context);
         };