@bitmovin/api-sdk 1.280.0 → 1.281.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.281.0',
             'Content-Type': 'application/json'
         };
         if (tenantOrgId) {

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,72 @@
+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;
+    /**
+     * 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,31 @@
+"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.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;

package/dist/models/AiSceneAnalysisLiveResultMetadata.js

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

package/dist/models/AiSceneAnalysisLiveSourceGap.d.ts

@@ -0,0 +1,27 @@
+import AiSceneAnalysisLiveSourceGapReason from './AiSceneAnalysisLiveSourceGapReason';
+/**
+ * @export
+ * @class AiSceneAnalysisLiveSourceGap
+ */
+export declare class AiSceneAnalysisLiveSourceGap {
+    /**
+     * Gap start on the monotonic analysis timeline (required)
+     * @type {number}
+     * @memberof AiSceneAnalysisLiveSourceGap
+     */
+    startTimeSeconds?: number;
+    /**
+     * Gap end on the monotonic analysis timeline (required)
+     * @type {number}
+     * @memberof AiSceneAnalysisLiveSourceGap
+     */
+    endTimeSeconds?: number;
+    /**
+     * Reason for the source gap (required)
+     * @type {AiSceneAnalysisLiveSourceGapReason}
+     * @memberof AiSceneAnalysisLiveSourceGap
+     */
+    reason?: AiSceneAnalysisLiveSourceGapReason;
+    constructor(obj?: Partial<AiSceneAnalysisLiveSourceGap>);
+}
+export default AiSceneAnalysisLiveSourceGap;

package/dist/models/AiSceneAnalysisLiveSourceGap.js

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

package/dist/models/AiSceneAnalysisLiveSourceGapReason.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @export
+ * @enum {string}
+ */
+export declare enum AiSceneAnalysisLiveSourceGapReason {
+    SOURCE_DISCONNECTED = "SOURCE_DISCONNECTED",
+    PROCESSING_MEDIA_PRESSURE = "PROCESSING_MEDIA_PRESSURE",
+    ANALYSIS_LAG = "ANALYSIS_LAG",
+    WINDOW_BUILD_FAILED = "WINDOW_BUILD_FAILED",
+    FINALIZATION_BACKLOG = "FINALIZATION_BACKLOG"
+}
+export default AiSceneAnalysisLiveSourceGapReason;

package/dist/models/AiSceneAnalysisLiveSourceGapReason.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiSceneAnalysisLiveSourceGapReason = void 0;
+/**
+ * @export
+ * @enum {string}
+ */
+var AiSceneAnalysisLiveSourceGapReason;
+(function (AiSceneAnalysisLiveSourceGapReason) {
+    AiSceneAnalysisLiveSourceGapReason["SOURCE_DISCONNECTED"] = "SOURCE_DISCONNECTED";
+    AiSceneAnalysisLiveSourceGapReason["PROCESSING_MEDIA_PRESSURE"] = "PROCESSING_MEDIA_PRESSURE";
+    AiSceneAnalysisLiveSourceGapReason["ANALYSIS_LAG"] = "ANALYSIS_LAG";
+    AiSceneAnalysisLiveSourceGapReason["WINDOW_BUILD_FAILED"] = "WINDOW_BUILD_FAILED";
+    AiSceneAnalysisLiveSourceGapReason["FINALIZATION_BACKLOG"] = "FINALIZATION_BACKLOG";
+})(AiSceneAnalysisLiveSourceGapReason || (exports.AiSceneAnalysisLiveSourceGapReason = AiSceneAnalysisLiveSourceGapReason = {}));
+exports.default = AiSceneAnalysisLiveSourceGapReason;

package/dist/models/AiSceneAnalysisLiveStatus.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @export
+ * @enum {string}
+ */
+export declare enum AiSceneAnalysisLiveStatus {
+    CREATED = "CREATED",
+    QUEUED = "QUEUED",
+    RUNNING = "RUNNING",
+    FINISHED = "FINISHED",
+    CANCELED = "CANCELED",
+    ERROR = "ERROR",
+    TRANSFER_ERROR = "TRANSFER_ERROR"
+}
+export default AiSceneAnalysisLiveStatus;