@norskvideo/norsk-sdk 1.0.367 → 1.0.370

package/lib/package.json

@@ -0,0 +1,46 @@
+{
+    "license": "MIT",
+    "name": "@norskvideo/norsk-sdk",
+    "version": "1.0.370",
+    "dependencies": {
+        "@bufbuild/protobuf": "^0.3.0",
+        "@grpc/grpc-js": "^1.2.2",
+        "@norskvideo/norsk-api": "1.0.370",
+        "lodash": "^4.17.21",
+        "typescript-nullable": "^0.6.0"
+    },
+    "files": [
+        "dist/norsk-sdk.d.ts",
+        "lib/**/*.js",
+        "lib/**/*d.ts",
+        "lib/src/tsdoc-metadata.json",
+        "package.json",
+        "src/*.ts",
+        "tsconfig.json"
+    ],
+    "scripts": {
+        "build": "npx tsc && npx eslint src",
+        "clean": "rm -rf lib",
+        "api-extractor": "rm -rf docs/gen/api-extractor && mkdir -p docs/gen/api-extractor/{temp,json,report} && npx api-extractor run --local --verbose",
+        "api-markdown": "npx api-documenter markdown --input-folder docs/gen/api-extractor/json --output-folder docs/gen/api-extractor/markdown"
+    },
+    "main": "./lib/src/sdk.js",
+    "types": "./lib/src/sdk.d.ts",
+    "exports": {
+        "types": "./lib/src/sdk.d.ts",
+        "import": "./lib/src/sdk.js",
+        "node": "./lib/src/sdk.js",
+        "require": "./lib/src/sdk.js",
+        "default": "./lib/src/sdk.js"
+    },
+    "prettier": {},
+    "devDependencies": {
+        "@microsoft/api-documenter": "^7.19.27",
+        "@microsoft/api-extractor": "^7.33.7",
+        "@typescript-eslint/eslint-plugin": "^6.2.0",
+        "@typescript-eslint/parser": "^6.2.0",
+        "eslint": "^8.46.0",
+        "@types/lodash": "^4.14.202",
+        "typescript": "^4.1.2"
+    }
+}

package/lib/src/media_nodes/common.d.ts

@@ -1,5 +1,8 @@
+/// <reference types="node" />
 import * as grpc from "@grpc/grpc-js";
 import { MediaClient as MediaClientPB } from "@norskvideo/norsk-api/lib/media_grpc_pb";
+import EventEmitter from "events";
+/** @public */
 export declare type MediaClient = {
     media: MediaClientPB;
     subscriptions: grpc.ClientDuplexStream<SubscriptionChannelMessage, SubscriptionChannelResponse>;
@@ -61,12 +64,23 @@ export interface StreamStatisticsMixin {
     stats: MultiStreamStatistics) => void;
     onGopStructure?: (structure: GopStructure) => void;
 }
+export declare type EventMap = {
+    [key: string]: (arg: any) => void;
+};
+export declare type MediaNodeStateEvents = {
+    close: (id: string) => void;
+};
 /** @public */
-export declare class MediaNodeState {
+export declare class MediaNodeState<Events extends EventMap & MediaNodeStateEvents = MediaNodeStateEvents> {
     id: MediaNodeId | undefined;
     closeAwait?: () => void;
     closed: boolean;
+    events: EventEmitter;
+    protected emit<E extends (keyof Events) & string>(name: E, arg: Parameters<Events[E]>[0]): void;
+    on<E extends (keyof Events) & string>(name: E, listener: Events[E]): void;
+    off<E extends (keyof Events) & string>(name: E, listener: Events[E]): void;
     constructor(client: MediaClient);
+    /** @public */
     close(): Promise<void>;
 }
 /** @public */
@@ -81,12 +95,18 @@ export declare type ReceiveFromAddressAuto = {
 };
 /** @public */
 export declare type PinToKey<Pins extends string> = Nullable<Partial<Record<Pins, StreamKey[]>>>;
+/** @public */
 export interface SubscribeDestination {
     id?: string;
     sourceContextChange(responseCallback: (error?: SubscriptionError) => void): Promise<boolean>;
+    on?: (e: "close", a: () => void) => void;
+    off?: (e: "close", a: () => void) => void;
 }
+export declare type SourceMediaNodeEvents = {
+    outboundContextChange: (streams: StreamMetadata[]) => void;
+} & MediaNodeStateEvents;
 /** @public */
-export declare class SourceMediaNode extends MediaNodeState {
+export declare class SourceMediaNode<Events extends SourceMediaNodeEvents = SourceMediaNodeEvents> extends MediaNodeState<Events> {
     outputStreams: StreamMetadata[];
     registerForContextChange(subscriber: SubscribeDestination): void;
     unregisterForContextChange(subscriber: SubscribeDestination): void;
@@ -106,7 +126,7 @@ export declare class SourceMediaNode extends MediaNodeState {
  * */
 export declare type SubscriptionValidationResponse = true | false | "accept" | "deny" | "accept_and_terminate" | "deny_and_queue" | "deny_and_drop";
 /** @public */
-export declare class SinkMediaNode<Pins extends string> extends MediaNodeState implements SubscribeDestination {
+export declare class SinkMediaNode<Pins extends string, Events extends MediaNodeStateEvents = MediaNodeStateEvents> extends MediaNodeState<Events> implements SubscribeDestination {
     permissiveSubscriptionValidation(_context: Context): SubscriptionValidationResponse;
     restrictiveSubscriptionValidation(context: Context): SubscriptionValidationResponse;
     /** Subscribe to the given sources.
@@ -129,7 +149,7 @@ export declare class SinkMediaNode<Pins extends string> extends MediaNodeState i
     finalise(): void;
 }
 /** @public */
-export declare class AutoSinkMediaNode<Pins extends string> extends SinkMediaNode<Pins | "auto"> {
+export declare class AutoSinkMediaNode<Pins extends string, Events extends MediaNodeStateEvents = MediaNodeStateEvents> extends SinkMediaNode<Pins | "auto", Events> {
     /** Subscribe to the given sources.
      *
      * This version of subscribe simply requires a list of stream keys to be

package/lib/src/media_nodes/common.js

@@ -13,8 +13,12 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerStreamHandlers = exports._ackContext = exports.AutoSinkMediaNode = exports.SinkMediaNode = exports.SourceMediaNode = exports.MediaNodeState = exports.applyMixins = void 0;
+const events_1 = __importDefault(require("events"));
 const media_pb_1 = require("@norskvideo/norsk-api/lib/media_pb");
 const constants_1 = require("@grpc/grpc-js/build/src/constants");
 const typescript_nullable_1 = require("typescript-nullable");
@@ -43,9 +47,20 @@ exports.applyMixins = applyMixins;
 class MediaNodeState {
     constructor(client) {
         this.closed = false;
+        this.events = new events_1.default();
         this.client = client;
         this.id = undefined;
     }
+    emit(name, arg) {
+        this.events.emit(name, arg);
+    }
+    on(name, listener) {
+        this.events.on(name, listener);
+    }
+    off(name, listener) {
+        this.events.off(name, listener);
+    }
+    /** @public */
     async close() {
         if (this.closed)
             return;
@@ -54,6 +69,8 @@ class MediaNodeState {
                 (0, utils_1.debuglog)("Sending close request for media node with id %s", this.id);
                 this.closeAwait = r;
                 this.client.media.closeMediaNode((0, utils_1.provideFull)(media_pb_1.MediaNodeId, { id: this.id }), () => { });
+                this.emit('close', this.id);
+                this.events.removeAllListeners();
             }
             else
                 r();
@@ -82,9 +99,16 @@ class SourceMediaNode extends MediaNodeState {
         this.onOutboundContextChange = onOutboundContextChange;
     }
     registerForContextChange(subscriber) {
-        this.subscribers.set(subscriber, null);
+        const closeCb = () => {
+            this.subscribers.delete(subscriber);
+        };
+        subscriber.on?.('close', closeCb);
+        this.subscribers.set(subscriber, closeCb);
     }
     unregisterForContextChange(subscriber) {
+        const closeCb = this.subscribers.get(subscriber);
+        if (closeCb)
+            subscriber.off?.('close', closeCb);
         this.subscribers.delete(subscriber);
     }
     /** @internal */
@@ -131,6 +155,8 @@ class SourceMediaNode extends MediaNodeState {
         if (this.onOutboundContextChange) {
             await this.onOutboundContextChange(this.outputStreams);
         }
+        // And some people might just want to know about it without blocking
+        this.emit('outboundContextChange', this.outputStreams);
         const pending = { pendingSubscribes: [], readyToAck: false };
         this.pendingContextAcks.set(context.blockingCallRef, pending);
         const notifications = [];
@@ -419,7 +445,7 @@ function registerStreamHandlers(grpcStream, unregisterNode, tag, reject, setting
         if (settings.onError) {
             return;
         }
-        console.log("Error:", source, err.code, constants_1.Status[err.code], err.details, err.metadata?.getMap());
+        (0, utils_1.errorlog)("Error:", source, err.code, constants_1.Status[err.code], err.details, err.metadata?.getMap());
     };
     grpcStream.on("end", () => {
         (0, utils_1.debuglog)(`End of ${tag} node`);

package/lib/src/media_nodes/input.d.ts

@@ -357,6 +357,10 @@ export interface LocalFileInputSettings extends InputSettings<SourceMediaNode> {
     /** An optional callback that will be invoked when file end is reached */
     onEof?: () => void;
 }
+/**
+ * @public
+ * see: {@link NorskInput.fileWebVtt}
+ */
 export interface WebVttFileInputSettings extends LocalFileInputSettings {
     /** Language tag to associate with the stream (optional) */
     language?: string;
@@ -369,6 +373,10 @@ export interface WebVttFileInputSettings extends LocalFileInputSettings {
  */
 export declare class FileWebVttInputNode extends SourceMediaNode {
 }
+/**
+ * @public
+ * see: {@link NorskInput.streamWebVtt}
+ */
 export interface StreamWebVttInputSettings extends InputSettings<StreamWebVttInputNode> {
     /** Language tag to associate with the stream (optional) */
     language?: string;
@@ -523,10 +531,12 @@ export interface UdpTsInputSettings extends RemoteInputSettings<UdpTsInputNode>
  */
 export declare class UdpTsInputNode extends TsCommonInputNode<UdpTsInputMessage, UdpTsInputNode> {
 }
+/** @public */
 export interface M3u8MediaInputSettings extends InputSettings<M3u8InputNode> {
     url: string;
 }
 /**
+ * @public
  * see: {@link NorskInput.m3u8Media}
  */
 export declare class M3u8InputNode extends TsCommonInputNode<M3u8MediaInputMessage, M3u8InputNode> {
@@ -616,7 +626,7 @@ export declare class AudioSignalGeneratorNode extends SourceMediaNode {
 /**
  * @public
  * Settings for an Video Testcard Generator
- * see: {@link NorskInput.videoTestcard}
+ * see: {@link NorskInput.videoTestCard}
  * */
 export interface VideoTestcardGeneratorSettings extends SourceNodeSettings<VideoTestcardGeneratorNode> {
     /** The source name to set in the stream key of the outgoing stream */
@@ -687,6 +697,11 @@ export interface FileMp4InputSettings extends SourceNodeSettings<FileMp4InputNod
     /** Whether to start paused or already playing (default: playing) */
     start?: 'playing' | 'paused';
 }
+/**
+ * @public
+ * Settings for updating a file-based Mp4 Input
+ * see: {@link FileMp4InputNode.updateSettings}
+ */
 export interface FileMp4InputSettingsUpdate {
     /** Whether to loop back to the start of the file after reaching the end */
     loop?: boolean;
@@ -762,13 +777,13 @@ export interface NorskInput {
     udpTs(settings: UdpTsInputSettings): Promise<UdpTsInputNode>;
     /**
      * Read subtitles from a WebVTT file on disk
-     * @param settings
+     * @param settings - Configuration for the file input
      */
     fileWebVtt(settings: WebVttFileInputSettings): Promise<FileWebVttInputNode>;
     /**
      * Stream subtitles in WebVTT format via API calls. Chunks of WebVTT cues can be sent
      * in an ongoing timeline (as if streaming a fragmented WebVTT file)
-     * @param settings
+     * @param settings - Configuration for the stream input
      */
     streamWebVtt(settings: StreamWebVttInputSettings): Promise<StreamWebVttInputNode>;
     /**

package/lib/src/media_nodes/input.js

@@ -977,6 +977,7 @@ class UdpTsInputNode extends TsCommonInputNode {
 }
 exports.UdpTsInputNode = UdpTsInputNode;
 /**
+ * @public
  * see: {@link NorskInput.m3u8Media}
  */
 class M3u8InputNode extends TsCommonInputNode {

package/lib/src/media_nodes/mediaStore.d.ts

@@ -99,7 +99,7 @@ declare type MediaStoreCut = {
 /**
  * @public
  * Settings to configure a media store recorder
- * see {@link NorskOutput.mediaStore}
+ * see {@link NorskMediaStore.recorder}
  */
 export interface MediaStoreRecorderSettings extends SinkNodeSettings<MediaStoreRecorderNode>, StreamStatisticsMixin {
     /**
@@ -121,7 +121,7 @@ export interface MediaStoreRecorderSettings extends SinkNodeSettings<MediaStoreR
 }
 /**
  * @public
- * see: {@link NorskOutput.mediaStore}
+ * see: {@link NorskMediaStore.recorder}
  */
 export declare class MediaStoreRecorderNode extends AutoSinkMediaNode<"audio" | "video"> {
     metadata(): Promise<MediaStoreSession[]>;
@@ -130,7 +130,7 @@ export declare class MediaStoreRecorderNode extends AutoSinkMediaNode<"audio" |
 /**
  * @public
  * Settings for Media Store playback
- * see: {@link NorskInput.mediaStore}
+ * see: {@link NorskMediaStore.player}
  */
 export interface MediaStorePlayerSettings extends InputSettings<MediaStorePlayerNode>, StreamStatisticsMixin {
     /**
@@ -142,13 +142,13 @@ export interface MediaStorePlayerSettings extends InputSettings<MediaStorePlayer
 }
 /**
  * @public
- * see: {@link NorskInput.mediaStore}
+ * see: {@link NorskMediaStore.player}
  */
 export declare class MediaStorePlayerNode extends SourceMediaNode {
 }
 /**
  * @public
- * see: {@link NorskOutput.mediaStore}
+ * see: {@link NorskMediaStore.makeCut}
  */
 export declare class MediaStoreActiveCut {
     /**
@@ -162,12 +162,12 @@ export declare class MediaStoreActiveCut {
 export declare type MediaStoreAssetFileWithHash = {
     file: string;
     hash: string;
-    errorOnHashMismatch?: boolean;
+    importIfNeeded?: boolean;
 };
 /** @public */
 export declare type MediaStoreAssetFile = {
     file: string;
-    errorOnHashMismatch?: boolean;
+    importIfNeeded?: boolean;
 };
 /** @public */
 export declare type MediaStoreAssetSource = MediaStoreAssetFileWithHash | MediaStoreAssetFile;
@@ -180,19 +180,22 @@ export declare type MediaStoreAssetSettings = {
 };
 /**
  * @public
- * see: {@link NorskOutput.mediaStore}
+ * see: {@link NorskMediaStore.asyncLoadAsset}
  */
 export declare class MediaStoreAsset {
     /** @public */
     durationMs?: bigint;
     /** @public */
     size?: bigint;
+    /** @public */
+    metadata?: MediaStoreSession[];
     cutListEntry(settings: MediaStoreAssetCut): MediaStoreCut;
+    close(): void;
 }
 /**
  * @public
  * Settings to configure a media store snapshot
- * see {@link NorskOutput.mediaStore}
+ * see {@link NorskMediaStore.snapshot}
  */
 export interface MediaStoreSnapshotSettings {
     /**
@@ -206,16 +209,17 @@ export interface MediaStoreSnapshotSettings {
 }
 /**
  * @public
- * see: {@link NorskOutput.mediaStore}
+ * see: {@link NorskMediaStore.snapshot}
  */
 export declare class MediaStoreSnapshot {
     update(): Promise<void>;
     metadata(): Promise<MediaStoreSession[]>;
     cutListEntry(settings: MediaStoreRecorderCut): MediaStoreCut;
+    close(): void;
 }
 /**
  * @public
- * Methods that allow you to ingest media into your application
+ * Methods to interact with the Media Store live-to-vod recording engine
  */
 export interface NorskMediaStore {
     /**
@@ -231,7 +235,7 @@ export interface NorskMediaStore {
     /**
      * Create a media store cut
      *
-     * @param cut request - Configuration for the cut
+     * @param request - Configuration for the cut
      */
     makeCut(request: MediaStoreCutRequest): MediaStoreActiveCut;
     /**

package/lib/src/media_nodes/mediaStore.js

@@ -89,7 +89,7 @@ function toSingleCuts(cuts) {
 }
 /**
  * @public
- * see: {@link NorskOutput.mediaStore}
+ * see: {@link NorskMediaStore.recorder}
  */
 class MediaStoreRecorderNode extends common_1.AutoSinkMediaNode {
     /** @internal */
@@ -154,6 +154,8 @@ class MediaStoreRecorderNode extends common_1.AutoSinkMediaNode {
         return node.initialised;
     }
     async metadata() {
+        if (this.closed)
+            throw new Error("Store Closed");
         const fn = util
             .promisify(this.client.media.mediaStoreMetadata)
             .bind(this.client.media);
@@ -161,6 +163,8 @@ class MediaStoreRecorderNode extends common_1.AutoSinkMediaNode {
             .then(fromMediaStoreMetadataResponse);
     }
     cutListEntry(settings) {
+        if (this.closed)
+            throw new Error("Store Closed");
         return {
             mediaStoreName: this.settings.name,
             cut: { type: "recorder", cut: settings }
@@ -170,7 +174,7 @@ class MediaStoreRecorderNode extends common_1.AutoSinkMediaNode {
 exports.MediaStoreRecorderNode = MediaStoreRecorderNode;
 /**
  * @public
- * see: {@link NorskInput.mediaStore}
+ * see: {@link NorskMediaStore.player}
  */
 class MediaStorePlayerNode extends common_1.SourceMediaNode {
     /** @internal */
@@ -223,7 +227,7 @@ class MediaStorePlayerNode extends common_1.SourceMediaNode {
 exports.MediaStorePlayerNode = MediaStorePlayerNode;
 /**
  * @public
- * see: {@link NorskOutput.mediaStore}
+ * see: {@link NorskMediaStore.makeCut}
  */
 class MediaStoreActiveCut {
     /** @internal */
@@ -242,7 +246,10 @@ class MediaStoreActiveCut {
         this.grpcStream = this.client.media.createMediaStoreCut();
         this._isComplete = false;
         this._complete = new Promise((resolve, reject) => {
-            this.grpcStream.on("error", (err) => { reject(err); });
+            this.grpcStream.on("error", (err) => {
+                this.grpcStream.destroy();
+                reject(err);
+            });
             this.grpcStream.on("data", (data) => {
                 const messageCase = data.message.case;
                 switch (messageCase) {
@@ -254,11 +261,13 @@ class MediaStoreActiveCut {
                     }
                     case "cutCancelled": {
                         this._isComplete = true;
+                        this.grpcStream.end();
                         reject(new Error("cancelled"));
                         break;
                     }
                     case "cutComplete": {
                         this._isComplete = true;
+                        this.grpcStream.end();
                         resolve(data.message.value.size);
                         break;
                     }
@@ -298,11 +307,13 @@ function isMediaStoreAssetFileWithHash(asset) {
 }
 /**
  * @public
- * see: {@link NorskOutput.mediaStore}
+ * see: {@link NorskMediaStore.asyncLoadAsset}
  */
 class MediaStoreAsset {
     /** @internal */
     constructor(settings, client) {
+        /** @internal */
+        this.closed = false;
         this.client = client;
         this.settings = settings;
         this.grpcStream = this.client.media.createMediaStoreAsset((0, common_1.provideFull)(media_pb_1.MediaStoreAssetSettings, {
@@ -313,19 +324,21 @@ class MediaStoreAsset {
                         fileWithHash: (0, common_1.provideFull)(media_pb_1.MediaStoreAssetFileWithHash, {
                             file: settings.source.file,
                             hash: settings.source.hash,
-                            errorOnHashMismatch: settings.source.errorOnHashMismatch ?? true
+                            importIfNeeded: settings.source.importIfNeeded ?? true
                         })
                     }) :
                     (0, common_1.mkMessageCase)({
                         file: (0, common_1.provideFull)(media_pb_1.MediaStoreAssetFile, {
                             file: settings.source.file,
-                            errorOnHashMismatch: settings.source.errorOnHashMismatch ?? true
+                            importIfNeeded: settings.source.importIfNeeded ?? true
                         })
                     })) : (0, common_1.mkMessageCase)({ noLoad: (0, common_1.provideFull)(protobuf_1.Empty, {}) })),
             path: settings.path
         }));
         this._ready = new Promise((resolve, reject) => {
             this.grpcStream.on("error", (err) => reject(err));
+            this.grpcStream.on("close", () => console.log("CLOSE"));
+            this.grpcStream.on("end", () => console.log("END"));
             this.grpcStream.on("data", (data) => {
                 const messageCase = data.message.case;
                 switch (messageCase) {
@@ -338,7 +351,16 @@ class MediaStoreAsset {
                     case "importComplete": {
                         this.durationMs = data.message.value.durationMs;
                         this.size = data.message.value.size;
-                        resolve(this);
+                        const metadataFn = util
+                            .promisify(this.client.media.mediaStoreMetadata)
+                            .bind(this.client.media);
+                        metadataFn((0, common_1.provideFull)(media_pb_1.MediaStoreMetadataRequest, { mediaStoreName: this.settings.name }))
+                            .then(fromMediaStoreMetadataResponse)
+                            .then((metadata) => {
+                            this.metadata = metadata;
+                            resolve(this);
+                        })
+                            .catch((err) => reject(err));
                         break;
                     }
                     default:
@@ -353,6 +375,8 @@ class MediaStoreAsset {
         return asset._ready;
     }
     cutListEntry(settings) {
+        if (this.closed)
+            throw new Error("Store Closed");
         if (this.durationMs == null) {
             throw new Error("Attempt to cut from an asset that isn't yet loaded");
         }
@@ -365,15 +389,24 @@ class MediaStoreAsset {
             cut: { type: "asset", cut: settings }
         };
     }
+    close() {
+        if (this.closed)
+            return;
+        this.grpcStream.cancel();
+        // this.grpcStream.destroy();
+        this.closed = true;
+    }
 }
 exports.MediaStoreAsset = MediaStoreAsset;
 /**
  * @public
- * see: {@link NorskOutput.mediaStore}
+ * see: {@link NorskMediaStore.snapshot}
  */
 class MediaStoreSnapshot {
     /** @internal */
     constructor(settings, client) {
+        /** @internal */
+        this.closed = false;
         this.client = client;
         this.settings = settings;
         this.grpcStream = this.client.media.createMediaStoreSnapshot();
@@ -413,6 +446,8 @@ class MediaStoreSnapshot {
         return snapshot._ready;
     }
     async update() {
+        if (this.closed)
+            throw new Error("Store Closed");
         if (this._updated) {
             return new Promise((_resolve, reject) => { reject(new Error("Update in progress")); });
         }
@@ -420,6 +455,8 @@ class MediaStoreSnapshot {
         return new Promise((resolve, reject) => { this._updated = { resolve, reject }; });
     }
     async metadata() {
+        if (this.closed)
+            throw new Error("Store Closed");
         const fn = util
             .promisify(this.client.media.mediaStoreMetadata)
             .bind(this.client.media);
@@ -427,11 +464,19 @@ class MediaStoreSnapshot {
             .then(fromMediaStoreMetadataResponse);
     }
     cutListEntry(settings) {
+        if (this.closed)
+            throw new Error("Store Closed");
         return {
             mediaStoreName: this.settings.name,
             cut: { type: "recorder", cut: settings }
         };
     }
+    close() {
+        if (this.closed)
+            return;
+        this.grpcStream.destroy();
+        this.closed = true;
+    }
 }
 exports.MediaStoreSnapshot = MediaStoreSnapshot;
 /** @internal */

package/lib/src/media_nodes/output.d.ts

@@ -43,6 +43,11 @@ export interface CmafOutputSettings extends SinkNodeSettings<CmafAudioOutputNode
      * The name to use for the playlist in a multivariant playlist
      */
     name?: string;
+    /**
+     * Whether to insert a program date-time directive on every segment. Not required to produce spec-compliant playlists,
+     * but may be useful for inspection or playlist manipulation
+     */
+    pdtEverySegment?: boolean;
 }
 /**
  * @public
@@ -75,6 +80,11 @@ export interface HlsTsVideoOutputSettings extends SinkNodeSettings<HlsTsVideoOut
      * The name to use for the playlist in a multivariant playlist
      */
     name?: string;
+    /**
+   * Whether to insert a program date-time directive on every segment. Not required to produce spec-compliant playlists,
+   * but may be useful for inspection or playlist manipulation
+   */
+    pdtEverySegment?: boolean;
 }
 /**
  * @public
@@ -107,6 +117,11 @@ export interface HlsTsAudioOutputSettings extends SinkNodeSettings<HlsTsAudioOut
      * The name to use for the playlist in a multivariant playlist
      */
     name?: string;
+    /**
+   * Whether to insert a program date-time directive on every segment. Not required to produce spec-compliant playlists,
+   * but may be useful for inspection or playlist manipulation
+   */
+    pdtEverySegment?: boolean;
 }
 /**
  * @public
@@ -127,6 +142,11 @@ export interface CmafWebVttOutputSettings extends SinkNodeSettings<CmafWebVttOut
      * The name to use for the playlist in a multivariant playlist
      */
     name?: string;
+    /**
+   * Whether to insert a program date-time directive on every segment. Not required to produce spec-compliant playlists,
+   * but may be useful for inspection or playlist manipulation
+   */
+    pdtEverySegment?: boolean;
 }
 /**
  * @public
@@ -170,6 +190,11 @@ export interface HlsTsCombinedPushOutputSettings extends SinkNodeSettings<HlsTsC
      * The name to use for the playlist in a multivariant playlist
      */
     name?: string;
+    /**
+   * Whether to insert a program date-time directive on every segment. Not required to produce spec-compliant playlists,
+   * but may be useful for inspection or playlist manipulation
+   */
+    pdtEverySegment?: boolean;
 }
 /**
  * @public