@norskvideo/norsk-sdk 1.0.348 → 1.0.350

package/dist/norsk-sdk.d.ts

@@ -18,13 +18,11 @@ 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 { OptionalBool } from '@norskvideo/norsk-api/lib/shared/common_pb';
-import { OptionalInt } from '@norskvideo/norsk-api/lib/shared/common_pb';
 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 } 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';
@@ -52,12 +50,20 @@ export declare interface AacSettings {
     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): void;
+    sendScte35(key: StreamKey, info: Scte35SpliceInfoSection_2): void;
 }
 
 export declare interface AncillarySettings extends ProcessorNodeSettings<AncillaryNode> {
-    onScte35?: (stream: StreamKey, message: Scte35SpliceInfoSection) => void;
+    onScte35?: (stream: StreamKey, message: Scte35SpliceInfoSection_2) => void;
     onSmpte2038?: (stream: StreamKey, message: Smpte2038Message) => void;
 }
 
@@ -512,7 +518,7 @@ export declare interface AwsS3PushDestinationSettings {
      * This can be used for supplying updates to configuration to this destination specifically
      * see: {@link UpdateCredentials}
      */
-    id: string;
+    id: DestinationId;
     /**
      * The AWS region being pushed to
      */
@@ -756,6 +762,8 @@ export declare function clientPortInternal(): string;
  * 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
@@ -812,14 +820,29 @@ export declare interface CmafMultiVariantOutputSettings extends SinkNodeSettings
      * 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> {
-    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, settings: ProcessorNodeSettings<T> & StreamStatisticsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => Promise<boolean>, _playlistPath: PlaylistPath, subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => void);
+    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, sessionId: string);
+    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
@@ -877,6 +900,10 @@ 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;
 }
 
 /**
@@ -884,6 +911,8 @@ export declare interface CmafOutputSettings extends SinkNodeSettings<CmafAudioOu
  * 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
@@ -898,6 +927,8 @@ export declare class CmafVideoOutputNode extends CmafNodeWithPlaylist<CmafVideoM
  * 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
@@ -941,7 +972,7 @@ export declare interface CmafWebVttOutputSettings extends SinkNodeSettings<CmafW
     /**
      * The maximum number of segments to display in a single generated playlist
      */
-    maximumPlaylistSegments: number;
+    maximumPlaylistSegments?: number;
 }
 
 /** @public */
@@ -1111,6 +1142,9 @@ 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
@@ -1329,6 +1363,74 @@ export declare interface FrameRate {
     seconds: number;
 }
 
+export declare type FrameStoreCut = {
+    startDateTime: Date;
+    durationMs: number;
+    sessionNum?: number;
+};
+
+/**
+ * @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"> {
+}
+
+/**
+ * @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;
+}
+
+export declare type FrameStoreStreamSelection = "all" | StreamKey[];
+
 export declare function fromVancPayloadFormat(format: VancPayloadFormat_2): VancPayloadFormat;
 
 /**
@@ -1355,6 +1457,21 @@ export declare interface HardwareInfo {
     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
@@ -1382,7 +1499,7 @@ export declare interface HlsPushDestinationSettings {
      * This can be used for supplying updates to configuration to this destination specifically
      * see: {@link UpdateCredentials}
      */
-    id: string;
+    id: DestinationId;
     /**
      * Informs the playlist generation how long segments will be retained for on the remote server
      * in order to generate an accurate playlist
@@ -1390,11 +1507,19 @@ export declare interface HlsPushDestinationSettings {
     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
@@ -1443,6 +1568,10 @@ 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;
 }
 
 /**
@@ -1524,13 +1653,24 @@ export declare interface HlsTsMultiVariantOutputSettings extends SinkNodeSetting
      * 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
@@ -1579,6 +1719,10 @@ 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 */
@@ -1600,6 +1744,16 @@ export declare interface InputSettings<T extends MediaNodeState> extends SourceN
     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;
@@ -1612,6 +1766,21 @@ export declare interface IntervalTimestamp {
     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}
@@ -1648,6 +1817,10 @@ export declare interface LocalFileInputSettings extends InputSettings<SourceMedi
  * */
 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
      *
@@ -1772,10 +1945,23 @@ 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;
+}
+
 /**
  * @public
  * Generate encryption parameters from from an encryption KeyID and Key,
@@ -1786,6 +1972,21 @@ export declare function mkEncryption(encryption: string | undefined, pssh?: stri
 /** @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[];
@@ -1825,7 +2026,7 @@ export declare interface NodeSettings<T extends MediaNodeState> {
      * 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?: () => void;
+    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)
@@ -1973,7 +2174,7 @@ export declare interface NorskInput {
      * This can be multicast/unicast or broadcast
      * @param settings - Configuration for the UDP input
      */
-    udpTs(settings: RemoteInputSettings<UdpTsInputNode>): Promise<UdpTsInputNode>;
+    udpTs(settings: UdpTsInputSettings): Promise<UdpTsInputNode>;
     fileWebVtt(settings: LocalFileInputSettings): Promise<FileWebVttInputNode>;
     /**
      * Read an image from a file. Various image formats are supported, see the
@@ -1993,6 +2194,8 @@ export declare interface NorskInput {
     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>;
@@ -2022,6 +2225,10 @@ export declare interface NorskInput {
      * @param settings - Settings for the SDI capture
      */
     deckLink(settings: DeckLinkInputSettings): Promise<DeckLinkInputNode>;
+    /**
+     * Playback from an existing Frame Store recording
+     */
+    frameStorePlayer(settings: FrameStorePlayerSettings): Promise<FrameStorePlayerNode>;
 }
 
 /**
@@ -2160,6 +2367,18 @@ export declare interface NorskOutput {
      * @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 */
@@ -2586,6 +2805,14 @@ export declare type PinToKey<Pins extends string> = Nullable<Partial<Record<Pins
 /** @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,
@@ -2628,6 +2855,11 @@ export declare class ProcessorMediaNode<Pins extends string> {
 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;
 
@@ -2787,6 +3019,11 @@ export declare interface Resolution {
     height: number;
 }
 
+/** @public */
+export declare enum RtmpConnectionFailureReason {
+    RtmpConnectionFailedRetry = "RtmpConnectionFailedRetry"
+}
+
 /**
  * @public
  * see: {@link NorskOutput.rtmp}
@@ -2808,6 +3045,16 @@ export declare interface RtmpOutputSettings extends SinkNodeSettings<RtmpOutputN
     bufferDelayMs?: 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;
+    };
 }
 
 /**
@@ -2830,6 +3077,11 @@ export declare class RtmpServerInputNode extends SourceMediaNode {
 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
@@ -2992,7 +3244,7 @@ export declare interface RtpStreamSettings {
     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 */
-    iface: string;
+    interface: string;
     /** The port to connect to for the RTP stream itself */
     rtpPort: number;
     /** The port to connect to for the associated RTCP stream */
@@ -3025,6 +3277,196 @@ export declare type SampleFormat =
 /** @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 */
 export declare function selectAudio(streams: readonly StreamMetadata[]): StreamKey[];
 
@@ -3375,7 +3817,7 @@ export declare interface StreamKeySettings {
 
 /** @public */
 export declare interface StreamMetadata {
-    streamKey?: StreamKey;
+    streamKey: StreamKey;
     message: StreamMetadataMessage;
 }
 
@@ -3415,7 +3857,7 @@ export declare class StreamMetadataOverrideNode extends AutoProcessorMediaNode<"
 
 /**
  * @public
- * Settings for a Stream Key Metadata Override Node
+ * Settings for a Stream Metadata Override Node
  * see: {@link NorskTransform.streamMetadataOverride}
  * */
 export declare interface StreamMetadataOverrideSettings extends ProcessorNodeSettings<StreamMetadataOverrideNode>, StreamMetadataOverrideSettingsUpdate {
@@ -3692,10 +4134,6 @@ export declare interface SubtitleStreamMetadata {
  */
 export declare function subtitleStreams(streams: readonly StreamMetadata[]): StreamMetadata[];
 
-export declare function toOptBool(b?: boolean): OptionalBool | undefined;
-
-export declare function toOptInt(i?: number): OptionalInt | undefined;
-
 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>);
     /**
@@ -3712,6 +4150,12 @@ declare enum TsInputType {
     M3u8 = 3
 }
 
+/** @public */
+export declare type TsPlaylist = MediaPlaylistPart[];
+
+/** @public */
+export declare type TsPlaylistAdditions = [MediaPlaylistPart[], Date];
+
 /**
  * @public
  * see: {@link NorskInput.udpTs}
@@ -3725,6 +4169,10 @@ export declare class UdpTsInputNode extends TsCommonInputNode<UdpTsInputMessage,
  * 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;
 }
 
 /**
@@ -3750,11 +4198,13 @@ export declare interface UdpTsOutputSettings extends SinkNodeSettings<UdpTsOutpu
      * This can be 'any', 'loopback' or any named interface on the machine
      * Note: If running inside docker this may be different to expected
      */
-    iface: string;
+    interface: string;
     /** The port to send to */
     port: number;
     /** Jitter buffer delay in milliseconds */
     bufferDelayMs?: number;
+    /** Whether to encapsulate in RTP via RFC 2250 (default: false) */
+    rtpEncapsulate?: boolean;
 }
 
 /**