@bitmovin/api-sdk 1.280.0 → 1.282.0

package/dist/common/RestClient.js

@@ -165,7 +165,7 @@ class HeaderHandler extends DelegatingHandler {
         const headers = {
             'X-Api-Key': apiKey,
             'X-Api-Client': 'bitmovin-api-sdk-javascript',
-            'X-Api-Client-Version': '1.280.0',
+            'X-Api-Client-Version': '1.282.0',
             'Content-Type': 'application/json'
         };
         if (tenantOrgId) {

package/dist/encoding/encodings/live/LiveApi.d.ts

@@ -2,6 +2,7 @@ import { BaseAPI } from '../../../common/BaseAPI';
 import Configuration from '../../../common/Configuration';
 import EsamApi from './esam/EsamApi';
 import ResetLiveManifestTimeshiftApi from './resetLiveManifestTimeshift/ResetLiveManifestTimeshiftApi';
+import UpdateAutoshutdownConfigApi from './updateAutoshutdownConfig/UpdateAutoshutdownConfigApi';
 import HeartbeatApi from './heartbeat/HeartbeatApi';
 import HeartbeatFinalApi from './heartbeatFinal/HeartbeatFinalApi';
 import HdApi from './hd/HdApi';
@@ -19,6 +20,7 @@ import StartLiveEncodingRequest from '../../../models/StartLiveEncodingRequest';
 export default class LiveApi extends BaseAPI {
     esam: EsamApi;
     resetLiveManifestTimeshift: ResetLiveManifestTimeshiftApi;
+    updateAutoshutdownConfig: UpdateAutoshutdownConfigApi;
     heartbeat: HeartbeatApi;
     heartbeatFinal: HeartbeatFinalApi;
     hd: HdApi;

package/dist/encoding/encodings/live/LiveApi.js

@@ -4,6 +4,7 @@ const BaseAPI_1 = require("../../../common/BaseAPI");
 const Mapper_1 = require("../../../common/Mapper");
 const EsamApi_1 = require("./esam/EsamApi");
 const ResetLiveManifestTimeshiftApi_1 = require("./resetLiveManifestTimeshift/ResetLiveManifestTimeshiftApi");
+const UpdateAutoshutdownConfigApi_1 = require("./updateAutoshutdownConfig/UpdateAutoshutdownConfigApi");
 const HeartbeatApi_1 = require("./heartbeat/HeartbeatApi");
 const HeartbeatFinalApi_1 = require("./heartbeatFinal/HeartbeatFinalApi");
 const HdApi_1 = require("./hd/HdApi");
@@ -23,6 +24,7 @@ class LiveApi extends BaseAPI_1.BaseAPI {
         super(configuration);
         this.esam = new EsamApi_1.default(configuration);
         this.resetLiveManifestTimeshift = new ResetLiveManifestTimeshiftApi_1.default(configuration);
+        this.updateAutoshutdownConfig = new UpdateAutoshutdownConfigApi_1.default(configuration);
         this.heartbeat = new HeartbeatApi_1.default(configuration);
         this.heartbeatFinal = new HeartbeatFinalApi_1.default(configuration);
         this.hd = new HdApi_1.default(configuration);

package/dist/encoding/encodings/live/updateAutoshutdownConfig/UpdateAutoshutdownConfigApi.d.ts

@@ -0,0 +1,21 @@
+import { BaseAPI } from '../../../../common/BaseAPI';
+import Configuration from '../../../../common/Configuration';
+import LiveAutoShutdownConfigurationUpdateRequest from '../../../../models/LiveAutoShutdownConfigurationUpdateRequest';
+import LiveAutoShutdownConfigurationUpdateResponse from '../../../../models/LiveAutoShutdownConfigurationUpdateResponse';
+/**
+ * UpdateAutoshutdownConfigApi - object-oriented interface
+ * @export
+ * @class UpdateAutoshutdownConfigApi
+ * @extends {BaseAPI}
+ */
+export default class UpdateAutoshutdownConfigApi extends BaseAPI {
+    constructor(configuration: Configuration);
+    /**
+     * @summary Replace Live Auto Shutdown Configuration
+     * @param {string} encodingId Id of the encoding.
+     * @param {LiveAutoShutdownConfigurationUpdateRequest} liveAutoShutdownConfigurationUpdateRequest Applies a new auto shutdown configuration to a Live Encoding that is already running, without interrupting the stream.  **The body is a full replacement, not a partial update.** Every field that is omitted or set to `null` disarms the corresponding timer, and an empty body `{}` disarms all timers. Always send the complete configuration you want the encoding to run with, including the values you want to keep.  **`streamTimeoutMinutes` is counted from this call, not from the start of the encoding.** The encoding is stopped that many minutes after the update is accepted, whereas in the start request the same field is counted from when the encoding started. An encoding started at 12:00 with `streamTimeoutMinutes` of 120 is scheduled to stop at 14:00; updating it at 13:30 with `streamTimeoutMinutes` of 150 moves the shutdown to 16:00, not to 14:30. `bytesReadTimeoutSeconds` is relative by nature, as it always counts from the last byte received, and `waitingForFirstConnectTimeoutMinutes` has no effect once the input is connected.  The organization's maximum live encoding runtime still bounds the total runtime of the encoding, measured from the start of the encoding. An update that would push the shutdown past that limit is rejected rather than extending the encoding beyond it.  **Do not leave the call to the last few seconds.** The update is rejected with `409` when any armed shutdown timer is within 10 seconds of firing, because at that point the shutdown sequence is effectively already in flight.
+     * @throws {BitmovinError}
+     * @memberof UpdateAutoshutdownConfigApi
+     */
+    create(encodingId: string, liveAutoShutdownConfigurationUpdateRequest?: LiveAutoShutdownConfigurationUpdateRequest): Promise<LiveAutoShutdownConfigurationUpdateResponse>;
+}

package/dist/encoding/encodings/live/updateAutoshutdownConfig/UpdateAutoshutdownConfigApi.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAPI_1 = require("../../../../common/BaseAPI");
+const Mapper_1 = require("../../../../common/Mapper");
+const LiveAutoShutdownConfigurationUpdateResponse_1 = require("../../../../models/LiveAutoShutdownConfigurationUpdateResponse");
+/**
+ * UpdateAutoshutdownConfigApi - object-oriented interface
+ * @export
+ * @class UpdateAutoshutdownConfigApi
+ * @extends {BaseAPI}
+ */
+class UpdateAutoshutdownConfigApi extends BaseAPI_1.BaseAPI {
+    constructor(configuration) {
+        super(configuration);
+    }
+    /**
+     * @summary Replace Live Auto Shutdown Configuration
+     * @param {string} encodingId Id of the encoding.
+     * @param {LiveAutoShutdownConfigurationUpdateRequest} liveAutoShutdownConfigurationUpdateRequest Applies a new auto shutdown configuration to a Live Encoding that is already running, without interrupting the stream.  **The body is a full replacement, not a partial update.** Every field that is omitted or set to `null` disarms the corresponding timer, and an empty body `{}` disarms all timers. Always send the complete configuration you want the encoding to run with, including the values you want to keep.  **`streamTimeoutMinutes` is counted from this call, not from the start of the encoding.** The encoding is stopped that many minutes after the update is accepted, whereas in the start request the same field is counted from when the encoding started. An encoding started at 12:00 with `streamTimeoutMinutes` of 120 is scheduled to stop at 14:00; updating it at 13:30 with `streamTimeoutMinutes` of 150 moves the shutdown to 16:00, not to 14:30. `bytesReadTimeoutSeconds` is relative by nature, as it always counts from the last byte received, and `waitingForFirstConnectTimeoutMinutes` has no effect once the input is connected.  The organization's maximum live encoding runtime still bounds the total runtime of the encoding, measured from the start of the encoding. An update that would push the shutdown past that limit is rejected rather than extending the encoding beyond it.  **Do not leave the call to the last few seconds.** The update is rejected with `409` when any armed shutdown timer is within 10 seconds of firing, because at that point the shutdown sequence is effectively already in flight.
+     * @throws {BitmovinError}
+     * @memberof UpdateAutoshutdownConfigApi
+     */
+    create(encodingId, liveAutoShutdownConfigurationUpdateRequest) {
+        const pathParamMap = {
+            encoding_id: encodingId
+        };
+        return this.restClient.post('/encoding/encodings/{encoding_id}/live/update-autoshutdown-config', pathParamMap, liveAutoShutdownConfigurationUpdateRequest).then((response) => {
+            return (0, Mapper_1.map)(response, LiveAutoShutdownConfigurationUpdateResponse_1.default);
+        });
+    }
+}
+exports.default = UpdateAutoshutdownConfigApi;

package/dist/models/AiSceneAnalysisLiveCreateRequest.d.ts

@@ -0,0 +1,42 @@
+import AiSceneAnalysisLiveOutput from './AiSceneAnalysisLiveOutput';
+import AiSceneAnalysisLiveRecordingRequest from './AiSceneAnalysisLiveRecordingRequest';
+import CloudRegion from './CloudRegion';
+/**
+ * Configuration for a Live Analysis. Each recording and analysis destination references an existing Encoding Output or provides an inline Output definition. Inline Outputs are created synchronously. Within this request, identical complete inline Output definitions, including credentials, are created once and reused across all destinations; destination paths and ACLs do not affect that reuse.
+ * @export
+ * @class AiSceneAnalysisLiveCreateRequest
+ */
+export declare class AiSceneAnalysisLiveCreateRequest {
+    /**
+     * Name of the Analysis
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveCreateRequest
+     */
+    name?: string;
+    /**
+     * Key used to publish the RTMP stream. When the Live Analysis is `RUNNING`, the Get Live Analysis details response returns the current value in `ingest.streamKey`. (required)
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveCreateRequest
+     */
+    streamKey?: string;
+    /**
+     * Region in which the AI analysis runs. `EXTERNAL` is not supported yet.
+     * @type {CloudRegion}
+     * @memberof AiSceneAnalysisLiveCreateRequest
+     */
+    cloudRegion?: CloudRegion;
+    /**
+     * Destinations for the stream recording (required)
+     * @type {AiSceneAnalysisLiveRecordingRequest}
+     * @memberof AiSceneAnalysisLiveCreateRequest
+     */
+    recording?: AiSceneAnalysisLiveRecordingRequest;
+    /**
+     * Destinations for cumulative AI analysis results (required)
+     * @type {AiSceneAnalysisLiveOutput[]}
+     * @memberof AiSceneAnalysisLiveCreateRequest
+     */
+    outputs?: AiSceneAnalysisLiveOutput[];
+    constructor(obj?: Partial<AiSceneAnalysisLiveCreateRequest>);
+}
+export default AiSceneAnalysisLiveCreateRequest;

package/dist/models/AiSceneAnalysisLiveCreateRequest.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiSceneAnalysisLiveCreateRequest = void 0;
+const Mapper_1 = require("../common/Mapper");
+const AiSceneAnalysisLiveOutput_1 = require("./AiSceneAnalysisLiveOutput");
+const AiSceneAnalysisLiveRecordingRequest_1 = require("./AiSceneAnalysisLiveRecordingRequest");
+/**
+ * Configuration for a Live Analysis. Each recording and analysis destination references an existing Encoding Output or provides an inline Output definition. Inline Outputs are created synchronously. Within this request, identical complete inline Output definitions, including credentials, are created once and reused across all destinations; destination paths and ACLs do not affect that reuse.
+ * @export
+ * @class AiSceneAnalysisLiveCreateRequest
+ */
+class AiSceneAnalysisLiveCreateRequest {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.name = (0, Mapper_1.map)(obj.name);
+        this.streamKey = (0, Mapper_1.map)(obj.streamKey);
+        this.cloudRegion = (0, Mapper_1.map)(obj.cloudRegion);
+        this.recording = (0, Mapper_1.map)(obj.recording, AiSceneAnalysisLiveRecordingRequest_1.default);
+        this.outputs = (0, Mapper_1.mapArray)(obj.outputs, AiSceneAnalysisLiveOutput_1.default);
+    }
+}
+exports.AiSceneAnalysisLiveCreateRequest = AiSceneAnalysisLiveCreateRequest;
+exports.default = AiSceneAnalysisLiveCreateRequest;

package/dist/models/AiSceneAnalysisLiveError.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @export
+ * @class AiSceneAnalysisLiveError
+ */
+export declare class AiSceneAnalysisLiveError {
+    /**
+     * Stable machine-readable failure code (required)
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveError
+     */
+    code?: string;
+    /**
+     * Credential-free failure description safe to expose to the customer (required)
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveError
+     */
+    message?: string;
+    /**
+     * Time at which the failure was recorded (required)
+     * @type {Date}
+     * @memberof AiSceneAnalysisLiveError
+     */
+    timestamp?: Date;
+    constructor(obj?: Partial<AiSceneAnalysisLiveError>);
+}
+export default AiSceneAnalysisLiveError;

package/dist/models/AiSceneAnalysisLiveError.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiSceneAnalysisLiveError = void 0;
+const Mapper_1 = require("../common/Mapper");
+/**
+ * @export
+ * @class AiSceneAnalysisLiveError
+ */
+class AiSceneAnalysisLiveError {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.code = (0, Mapper_1.map)(obj.code);
+        this.message = (0, Mapper_1.map)(obj.message);
+        this.timestamp = (0, Mapper_1.map)(obj.timestamp, Date);
+    }
+}
+exports.AiSceneAnalysisLiveError = AiSceneAnalysisLiveError;
+exports.default = AiSceneAnalysisLiveError;

package/dist/models/AiSceneAnalysisLiveObservation.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Immutable consumer-visible observation produced from an analyzed media window
+ * @export
+ * @class AiSceneAnalysisLiveObservation
+ */
+export declare class AiSceneAnalysisLiveObservation {
+    /**
+     * Stable opaque observation ID that remains unchanged across cumulative result generations (required)
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveObservation
+     */
+    id?: string;
+    /**
+     * Consumer-visible description of a development in the analyzed media (required)
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveObservation
+     */
+    text?: string;
+    /**
+     * Start of the analyzed media window that produced the observation (required)
+     * @type {number}
+     * @memberof AiSceneAnalysisLiveObservation
+     */
+    startTimeSeconds?: number;
+    /**
+     * End of the analyzed media window that produced the observation (required)
+     * @type {number}
+     * @memberof AiSceneAnalysisLiveObservation
+     */
+    endTimeSeconds?: number;
+    constructor(obj?: Partial<AiSceneAnalysisLiveObservation>);
+}
+export default AiSceneAnalysisLiveObservation;

package/dist/models/AiSceneAnalysisLiveObservation.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiSceneAnalysisLiveObservation = void 0;
+const Mapper_1 = require("../common/Mapper");
+/**
+ * Immutable consumer-visible observation produced from an analyzed media window
+ * @export
+ * @class AiSceneAnalysisLiveObservation
+ */
+class AiSceneAnalysisLiveObservation {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.id = (0, Mapper_1.map)(obj.id);
+        this.text = (0, Mapper_1.map)(obj.text);
+        this.startTimeSeconds = (0, Mapper_1.map)(obj.startTimeSeconds);
+        this.endTimeSeconds = (0, Mapper_1.map)(obj.endTimeSeconds);
+    }
+}
+exports.AiSceneAnalysisLiveObservation = AiSceneAnalysisLiveObservation;
+exports.default = AiSceneAnalysisLiveObservation;

package/dist/models/AiSceneAnalysisLiveOutput.d.ts

@@ -0,0 +1,34 @@
+import AclEntry from './AclEntry';
+import Output from './Output';
+/**
+ * @export
+ * @class AiSceneAnalysisLiveOutput
+ */
+export declare class AiSceneAnalysisLiveOutput {
+    /**
+     * ID of an existing Encoding Output owned by the organization. Set either this property or `output`, but not both.
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveOutput
+     */
+    outputId?: string;
+    /**
+     * Inline definition of a concrete, publicly creatable Encoding Output to create synchronously. Only properties defined by the selected concrete Output type are accepted; internal types and properties are not supported. Deprecated properties that remain supported by the Encoding Output creation API are accepted. Set either this property or `outputId`, but not both. Put ACL entries on the destination-level `acl` property, not in this resource definition. The created Output is an ordinary reusable Encoding resource and is not automatically deleted with the Live Analysis or after provisioning failure.
+     * @type {Output}
+     * @memberof AiSceneAnalysisLiveOutput
+     */
+    output?: Output;
+    /**
+     * Subdirectory where files are written. This destination setting is not part of the inline Output resource definition. (required)
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveOutput
+     */
+    outputPath?: string;
+    /**
+     * Determines accessibility of files written to this destination. Only applies to Output types that support ACLs. Defaults to PUBLIC_READ if the list is empty.
+     * @type {AclEntry[]}
+     * @memberof AiSceneAnalysisLiveOutput
+     */
+    acl?: AclEntry[];
+    constructor(obj?: Partial<AiSceneAnalysisLiveOutput>);
+}
+export default AiSceneAnalysisLiveOutput;

package/dist/models/AiSceneAnalysisLiveOutput.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiSceneAnalysisLiveOutput = void 0;
+const Mapper_1 = require("../common/Mapper");
+const AclEntry_1 = require("./AclEntry");
+const Output_1 = require("./Output");
+/**
+ * @export
+ * @class AiSceneAnalysisLiveOutput
+ */
+class AiSceneAnalysisLiveOutput {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.outputId = (0, Mapper_1.map)(obj.outputId);
+        this.output = (0, Mapper_1.map)(obj.output, Output_1.default);
+        this.outputPath = (0, Mapper_1.map)(obj.outputPath);
+        this.acl = (0, Mapper_1.mapArray)(obj.acl, AclEntry_1.default);
+    }
+}
+exports.AiSceneAnalysisLiveOutput = AiSceneAnalysisLiveOutput;
+exports.default = AiSceneAnalysisLiveOutput;

package/dist/models/AiSceneAnalysisLiveRecording.d.ts

@@ -0,0 +1,16 @@
+import EncodingOutput from './EncodingOutput';
+/**
+ * Resolved output configuration for the stream recording
+ * @export
+ * @class AiSceneAnalysisLiveRecording
+ */
+export declare class AiSceneAnalysisLiveRecording {
+    /**
+     * Resolved Encoding Output ID references for the stream recording (required)
+     * @type {EncodingOutput[]}
+     * @memberof AiSceneAnalysisLiveRecording
+     */
+    outputs?: EncodingOutput[];
+    constructor(obj?: Partial<AiSceneAnalysisLiveRecording>);
+}
+export default AiSceneAnalysisLiveRecording;

package/dist/models/AiSceneAnalysisLiveRecording.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiSceneAnalysisLiveRecording = void 0;
+const Mapper_1 = require("../common/Mapper");
+const EncodingOutput_1 = require("./EncodingOutput");
+/**
+ * Resolved output configuration for the stream recording
+ * @export
+ * @class AiSceneAnalysisLiveRecording
+ */
+class AiSceneAnalysisLiveRecording {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.outputs = (0, Mapper_1.mapArray)(obj.outputs, EncodingOutput_1.default);
+    }
+}
+exports.AiSceneAnalysisLiveRecording = AiSceneAnalysisLiveRecording;
+exports.default = AiSceneAnalysisLiveRecording;

package/dist/models/AiSceneAnalysisLiveRecordingRequest.d.ts

@@ -0,0 +1,15 @@
+import AiSceneAnalysisLiveOutput from './AiSceneAnalysisLiveOutput';
+/**
+ * @export
+ * @class AiSceneAnalysisLiveRecordingRequest
+ */
+export declare class AiSceneAnalysisLiveRecordingRequest {
+    /**
+     * Destinations for the stream recording (required)
+     * @type {AiSceneAnalysisLiveOutput[]}
+     * @memberof AiSceneAnalysisLiveRecordingRequest
+     */
+    outputs?: AiSceneAnalysisLiveOutput[];
+    constructor(obj?: Partial<AiSceneAnalysisLiveRecordingRequest>);
+}
+export default AiSceneAnalysisLiveRecordingRequest;

package/dist/models/AiSceneAnalysisLiveRecordingRequest.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiSceneAnalysisLiveRecordingRequest = void 0;
+const Mapper_1 = require("../common/Mapper");
+const AiSceneAnalysisLiveOutput_1 = require("./AiSceneAnalysisLiveOutput");
+/**
+ * @export
+ * @class AiSceneAnalysisLiveRecordingRequest
+ */
+class AiSceneAnalysisLiveRecordingRequest {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.outputs = (0, Mapper_1.mapArray)(obj.outputs, AiSceneAnalysisLiveOutput_1.default);
+    }
+}
+exports.AiSceneAnalysisLiveRecordingRequest = AiSceneAnalysisLiveRecordingRequest;
+exports.default = AiSceneAnalysisLiveRecordingRequest;

package/dist/models/AiSceneAnalysisLiveResponse.d.ts

@@ -0,0 +1,67 @@
+import AiSceneAnalysisLiveError from './AiSceneAnalysisLiveError';
+import AiSceneAnalysisLiveRecording from './AiSceneAnalysisLiveRecording';
+import AiSceneAnalysisLiveStatus from './AiSceneAnalysisLiveStatus';
+import EncodingOutput from './EncodingOutput';
+import LiveEncoding from './LiveEncoding';
+/**
+ * @export
+ * @class AiSceneAnalysisLiveResponse
+ */
+export declare class AiSceneAnalysisLiveResponse {
+    /**
+     * ID of the Live Analysis resource (required)
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveResponse
+     */
+    analysisId?: string;
+    /**
+     * ID of the Encoding associated with the Analysis (required)
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveResponse
+     */
+    encodingId?: string;
+    /**
+     * Name of the Analysis
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveResponse
+     */
+    name?: string;
+    /**
+     * Current lifecycle state of the Live Analysis (required)
+     * @type {AiSceneAnalysisLiveStatus}
+     * @memberof AiSceneAnalysisLiveResponse
+     */
+    status?: AiSceneAnalysisLiveStatus;
+    /**
+     * Resolved output configuration for the stream recording (required)
+     * @type {AiSceneAnalysisLiveRecording}
+     * @memberof AiSceneAnalysisLiveResponse
+     */
+    recording?: AiSceneAnalysisLiveRecording;
+    /**
+     * Resolved Encoding Output ID references for cumulative AI analysis results (required)
+     * @type {EncodingOutput[]}
+     * @memberof AiSceneAnalysisLiveResponse
+     */
+    outputs?: EncodingOutput[];
+    /**
+     * Current RTMP ingest details. Present only in the Get Live Analysis details response while the Live Analysis is `RUNNING`.
+     * @type {LiveEncoding}
+     * @memberof AiSceneAnalysisLiveResponse
+     */
+    ingest?: LiveEncoding;
+    /**
+     * Failure details. Present only when the status is `ERROR` or `TRANSFER_ERROR`.
+     * @type {AiSceneAnalysisLiveError}
+     * @memberof AiSceneAnalysisLiveResponse
+     */
+    error?: AiSceneAnalysisLiveError;
+    /**
+     * Creation timestamp, returned as UTC in ISO 8601 format: YYYY-MM-DDThh:mm:ssZ (required)
+     * @type {Date}
+     * @memberof AiSceneAnalysisLiveResponse
+     */
+    createdAt?: Date;
+    constructor(obj?: Partial<AiSceneAnalysisLiveResponse>);
+}
+export default AiSceneAnalysisLiveResponse;

package/dist/models/AiSceneAnalysisLiveResponse.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiSceneAnalysisLiveResponse = void 0;
+const Mapper_1 = require("../common/Mapper");
+const AiSceneAnalysisLiveError_1 = require("./AiSceneAnalysisLiveError");
+const AiSceneAnalysisLiveRecording_1 = require("./AiSceneAnalysisLiveRecording");
+const EncodingOutput_1 = require("./EncodingOutput");
+const LiveEncoding_1 = require("./LiveEncoding");
+/**
+ * @export
+ * @class AiSceneAnalysisLiveResponse
+ */
+class AiSceneAnalysisLiveResponse {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.analysisId = (0, Mapper_1.map)(obj.analysisId);
+        this.encodingId = (0, Mapper_1.map)(obj.encodingId);
+        this.name = (0, Mapper_1.map)(obj.name);
+        this.status = (0, Mapper_1.map)(obj.status);
+        this.recording = (0, Mapper_1.map)(obj.recording, AiSceneAnalysisLiveRecording_1.default);
+        this.outputs = (0, Mapper_1.mapArray)(obj.outputs, EncodingOutput_1.default);
+        this.ingest = (0, Mapper_1.map)(obj.ingest, LiveEncoding_1.default);
+        this.error = (0, Mapper_1.map)(obj.error, AiSceneAnalysisLiveError_1.default);
+        this.createdAt = (0, Mapper_1.map)(obj.createdAt, Date);
+    }
+}
+exports.AiSceneAnalysisLiveResponse = AiSceneAnalysisLiveResponse;
+exports.default = AiSceneAnalysisLiveResponse;

package/dist/models/AiSceneAnalysisLiveResult.d.ts

@@ -0,0 +1,78 @@
+import AiSceneAnalysisLiveObservation from './AiSceneAnalysisLiveObservation';
+import AiSceneAnalysisLiveResultMetadata from './AiSceneAnalysisLiveResultMetadata';
+import AiSceneAnalysisLiveSourceGap from './AiSceneAnalysisLiveSourceGap';
+/**
+ * Cumulative immutable result generation for a Live Analysis
+ * @export
+ * @class AiSceneAnalysisLiveResult
+ */
+export declare class AiSceneAnalysisLiveResult {
+    /**
+     * ID of the Live Analysis resource (required)
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveResult
+     */
+    analysisId?: string;
+    /**
+     * ID of the Encoding associated with the Analysis (required)
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveResult
+     */
+    encodingId?: string;
+    /**
+     * Monotonically increasing generation sequence, starting at 1 (required)
+     * @type {number}
+     * @memberof AiSceneAnalysisLiveResult
+     */
+    sequence?: number;
+    /**
+     * Time at which the AI analysis produced this result generation (required)
+     * @type {Date}
+     * @memberof AiSceneAnalysisLiveResult
+     */
+    producedAt?: Date;
+    /**
+     * UTC presentation-clock time in Unix milliseconds corresponding to media time zero. This origin is fixed for the Live Analysis; coverage, observation, and source-gap times remain relative to it. It is not the source capture time or result publication time. (required)
+     * @type {number}
+     * @memberof AiSceneAnalysisLiveResult
+     */
+    mediaTimeOriginUnixMs?: number;
+    /**
+     * Whether AI analysis produced this as the final result generation. This does not by itself imply that the Analysis completed successfully. (required)
+     * @type {boolean}
+     * @memberof AiSceneAnalysisLiveResult
+     */
+    isFinal?: boolean;
+    /**
+     * Start of cumulative analyzed coverage on the monotonic analysis timeline (required)
+     * @type {number}
+     * @memberof AiSceneAnalysisLiveResult
+     */
+    analyzedStartTimeSeconds?: number;
+    /**
+     * End of cumulative analyzed coverage on the monotonic analysis timeline (required)
+     * @type {number}
+     * @memberof AiSceneAnalysisLiveResult
+     */
+    analyzedEndTimeSeconds?: number;
+    /**
+     * Cumulative closed source gaps on the monotonic analysis timeline (required)
+     * @type {AiSceneAnalysisLiveSourceGap[]}
+     * @memberof AiSceneAnalysisLiveResult
+     */
+    sourceGaps?: AiSceneAnalysisLiveSourceGap[];
+    /**
+     * Producer metadata for this generation (required)
+     * @type {AiSceneAnalysisLiveResultMetadata}
+     * @memberof AiSceneAnalysisLiveResult
+     */
+    metadata?: AiSceneAnalysisLiveResultMetadata;
+    /**
+     * Cumulative immutable observations. Existing observations retain the same ID and content across later generations. Each time range identifies the analyzed media window that produced the observation, not an exact event location. (required)
+     * @type {AiSceneAnalysisLiveObservation[]}
+     * @memberof AiSceneAnalysisLiveResult
+     */
+    observations?: AiSceneAnalysisLiveObservation[];
+    constructor(obj?: Partial<AiSceneAnalysisLiveResult>);
+}
+export default AiSceneAnalysisLiveResult;

package/dist/models/AiSceneAnalysisLiveResult.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiSceneAnalysisLiveResult = void 0;
+const Mapper_1 = require("../common/Mapper");
+const AiSceneAnalysisLiveObservation_1 = require("./AiSceneAnalysisLiveObservation");
+const AiSceneAnalysisLiveResultMetadata_1 = require("./AiSceneAnalysisLiveResultMetadata");
+const AiSceneAnalysisLiveSourceGap_1 = require("./AiSceneAnalysisLiveSourceGap");
+/**
+ * Cumulative immutable result generation for a Live Analysis
+ * @export
+ * @class AiSceneAnalysisLiveResult
+ */
+class AiSceneAnalysisLiveResult {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.analysisId = (0, Mapper_1.map)(obj.analysisId);
+        this.encodingId = (0, Mapper_1.map)(obj.encodingId);
+        this.sequence = (0, Mapper_1.map)(obj.sequence);
+        this.producedAt = (0, Mapper_1.map)(obj.producedAt, Date);
+        this.mediaTimeOriginUnixMs = (0, Mapper_1.map)(obj.mediaTimeOriginUnixMs);
+        this.isFinal = (0, Mapper_1.map)(obj.isFinal);
+        this.analyzedStartTimeSeconds = (0, Mapper_1.map)(obj.analyzedStartTimeSeconds);
+        this.analyzedEndTimeSeconds = (0, Mapper_1.map)(obj.analyzedEndTimeSeconds);
+        this.sourceGaps = (0, Mapper_1.mapArray)(obj.sourceGaps, AiSceneAnalysisLiveSourceGap_1.default);
+        this.metadata = (0, Mapper_1.map)(obj.metadata, AiSceneAnalysisLiveResultMetadata_1.default);
+        this.observations = (0, Mapper_1.mapArray)(obj.observations, AiSceneAnalysisLiveObservation_1.default);
+    }
+}
+exports.AiSceneAnalysisLiveResult = AiSceneAnalysisLiveResult;
+exports.default = AiSceneAnalysisLiveResult;

package/dist/models/AiSceneAnalysisLiveResultMetadata.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @export
+ * @class AiSceneAnalysisLiveResultMetadata
+ */
+export declare class AiSceneAnalysisLiveResultMetadata {
+    /**
+     * Version of the AI analysis software (required)
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveResultMetadata
+     */
+    version?: string;
+    /**
+     * Disclaimer associated with AI-generated analysis data (required)
+     * @type {string}
+     * @memberof AiSceneAnalysisLiveResultMetadata
+     */
+    disclaimer?: string;
+    constructor(obj?: Partial<AiSceneAnalysisLiveResultMetadata>);
+}
+export default AiSceneAnalysisLiveResultMetadata;