@bitmovin/api-sdk 1.279.0 → 1.281.0

package/dist/models/PccDevice.d.ts

@@ -0,0 +1,56 @@
+import PccCell from './PccCell';
+import PccDeviceUnit from './PccDeviceUnit';
+/**
+ * @export
+ * @class PccDevice
+ */
+export declare class PccDevice {
+    /**
+     * The device pool, as the reader is shown it. (required)
+     * @type {string}
+     * @memberof PccDevice
+     */
+    name?: string;
+    /**
+     * True where no naming rule recognised this pool, so `name` is a stated placeholder rather than the pool's own. The units and sessions below still tell two such pools apart. (required)
+     * @type {boolean}
+     * @memberof PccDevice
+     */
+    namePlaceholder?: boolean;
+    /**
+     * What distinguishes this pool from another of the same name, where anything does.
+     * @type {string}
+     * @memberof PccDevice
+     */
+    qualifier?: string;
+    /**
+     * The fleet's own classification, such as `tv`, `desktop`, `stb` or `mobile`. Never one guessed from a name, and not a closed set: the fleet may answer with a kind this list does not name.
+     * @type {string}
+     * @memberof PccDevice
+     */
+    deviceType?: string;
+    /**
+     * @type {string[]}
+     * @memberof PccDevice
+     */
+    sessionIds?: string[];
+    /**
+     * @type {PccDeviceUnit[]}
+     * @memberof PccDevice
+     */
+    units?: PccDeviceUnit[];
+    /**
+     * Every player version that measured this pool. More than one means the runs spanned a player release. (required)
+     * @type {string[]}
+     * @memberof PccDevice
+     */
+    playerVersions?: string[];
+    /**
+     * One per column, in `combinations` order. (required)
+     * @type {PccCell[]}
+     * @memberof PccDevice
+     */
+    cells?: PccCell[];
+    constructor(obj?: Partial<PccDevice>);
+}
+export default PccDevice;

package/dist/models/PccDevice.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PccDevice = void 0;
+const Mapper_1 = require("../common/Mapper");
+const PccCell_1 = require("./PccCell");
+const PccDeviceUnit_1 = require("./PccDeviceUnit");
+/**
+ * @export
+ * @class PccDevice
+ */
+class PccDevice {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.name = (0, Mapper_1.map)(obj.name);
+        this.namePlaceholder = (0, Mapper_1.map)(obj.namePlaceholder);
+        this.qualifier = (0, Mapper_1.map)(obj.qualifier);
+        this.deviceType = (0, Mapper_1.map)(obj.deviceType);
+        this.sessionIds = (0, Mapper_1.mapArray)(obj.sessionIds);
+        this.units = (0, Mapper_1.mapArray)(obj.units, PccDeviceUnit_1.default);
+        this.playerVersions = (0, Mapper_1.mapArray)(obj.playerVersions);
+        this.cells = (0, Mapper_1.mapArray)(obj.cells, PccCell_1.default);
+    }
+}
+exports.PccDevice = PccDevice;
+exports.default = PccDevice;

package/dist/models/PccDeviceHdrVerdict.d.ts

@@ -0,0 +1,35 @@
+import PccHdrConfidence from './PccHdrConfidence';
+/**
+ * @export
+ * @class PccDeviceHdrVerdict
+ */
+export declare class PccDeviceHdrVerdict {
+    /**
+     * @type {string}
+     * @memberof PccDeviceHdrVerdict
+     */
+    mark?: string;
+    /**
+     * @type {string}
+     * @memberof PccDeviceHdrVerdict
+     */
+    label?: string;
+    /**
+     * @type {PccHdrConfidence}
+     * @memberof PccDeviceHdrVerdict
+     */
+    confidence?: PccHdrConfidence;
+    /**
+     * @type {boolean}
+     * @memberof PccDeviceHdrVerdict
+     */
+    actionable?: boolean;
+    /**
+     * HDR passes supporting this verdict, not all passes for the device. (required)
+     * @type {number}
+     * @memberof PccDeviceHdrVerdict
+     */
+    passes?: number;
+    constructor(obj?: Partial<PccDeviceHdrVerdict>);
+}
+export default PccDeviceHdrVerdict;

package/dist/models/PccDeviceHdrVerdict.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PccDeviceHdrVerdict = void 0;
+const Mapper_1 = require("../common/Mapper");
+/**
+ * @export
+ * @class PccDeviceHdrVerdict
+ */
+class PccDeviceHdrVerdict {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.mark = (0, Mapper_1.map)(obj.mark);
+        this.label = (0, Mapper_1.map)(obj.label);
+        this.confidence = (0, Mapper_1.map)(obj.confidence);
+        this.actionable = (0, Mapper_1.map)(obj.actionable);
+        this.passes = (0, Mapper_1.map)(obj.passes);
+    }
+}
+exports.PccDeviceHdrVerdict = PccDeviceHdrVerdict;
+exports.default = PccDeviceHdrVerdict;

package/dist/models/PccDeviceTypeShare.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @export
+ * @class PccDeviceTypeShare
+ */
+export declare class PccDeviceTypeShare {
+    /**
+     * The device type reported by the fleet. (required)
+     * @type {string}
+     * @memberof PccDeviceTypeShare
+     */
+    label?: string;
+    /**
+     * Cells that played, across device pools of this kind. (required)
+     * @type {number}
+     * @memberof PccDeviceTypeShare
+     */
+    played?: number;
+    /**
+     * Cells with a device-answering verdict, across pools of this kind. The denominator. (required)
+     * @type {number}
+     * @memberof PccDeviceTypeShare
+     */
+    measured?: number;
+    /**
+     * Device pools of this kind with at least one device-answering verdict. (required)
+     * @type {number}
+     * @memberof PccDeviceTypeShare
+     */
+    models?: number;
+    constructor(obj?: Partial<PccDeviceTypeShare>);
+}
+export default PccDeviceTypeShare;

package/dist/models/PccDeviceTypeShare.js

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

package/dist/models/PccDeviceUnit.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @export
+ * @class PccDeviceUnit
+ */
+export declare class PccDeviceUnit {
+    /**
+     * The fleet's identifier for one physical machine, so two rows of the same pool can be told apart. (required)
+     * @type {string}
+     * @memberof PccDeviceUnit
+     */
+    unitId?: string;
+    /**
+     * @type {string[]}
+     * @memberof PccDeviceUnit
+     */
+    sessionIds?: string[];
+    /**
+     * @type {string}
+     * @memberof PccDeviceUnit
+     */
+    browserVersion?: string;
+    /**
+     * @type {string}
+     * @memberof PccDeviceUnit
+     */
+    osVersion?: string;
+    /**
+     * Attribute tags such as `webos:firmwareVersion:33.23.05`, which is where a television's firmware lives.
+     * @type {string[]}
+     * @memberof PccDeviceUnit
+     */
+    tags?: string[];
+    constructor(obj?: Partial<PccDeviceUnit>);
+}
+export default PccDeviceUnit;

package/dist/models/PccDeviceUnit.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PccDeviceUnit = void 0;
+const Mapper_1 = require("../common/Mapper");
+/**
+ * @export
+ * @class PccDeviceUnit
+ */
+class PccDeviceUnit {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.unitId = (0, Mapper_1.map)(obj.unitId);
+        this.sessionIds = (0, Mapper_1.mapArray)(obj.sessionIds);
+        this.browserVersion = (0, Mapper_1.map)(obj.browserVersion);
+        this.osVersion = (0, Mapper_1.map)(obj.osVersion);
+        this.tags = (0, Mapper_1.mapArray)(obj.tags);
+    }
+}
+exports.PccDeviceUnit = PccDeviceUnit;
+exports.default = PccDeviceUnit;

package/dist/models/PccHdrConfidence.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Which instrument established the picture, where anything did.
+ * @export
+ * @enum {string}
+ */
+export declare enum PccHdrConfidence {
+    EVIDENCE = "evidence",
+    CLAIM = "claim",
+    UNESTABLISHED = "unestablished"
+}
+export default PccHdrConfidence;

package/dist/models/PccHdrConfidence.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PccHdrConfidence = void 0;
+/**
+ * Which instrument established the picture, where anything did.
+ * @export
+ * @enum {string}
+ */
+var PccHdrConfidence;
+(function (PccHdrConfidence) {
+    PccHdrConfidence["EVIDENCE"] = "evidence";
+    PccHdrConfidence["CLAIM"] = "claim";
+    PccHdrConfidence["UNESTABLISHED"] = "unestablished";
+})(PccHdrConfidence || (exports.PccHdrConfidence = PccHdrConfidence = {}));
+exports.default = PccHdrConfidence;

package/dist/models/PccHdrDevice.d.ts

@@ -0,0 +1,43 @@
+import PccDeviceHdrVerdict from './PccDeviceHdrVerdict';
+import PccHdrOutcomeCount from './PccHdrOutcomeCount';
+/**
+ * @export
+ * @class PccHdrDevice
+ */
+export declare class PccHdrDevice {
+    /**
+     * Opaque stable pool key for row identity. Do not display it as a device name. (required)
+     * @type {string}
+     * @memberof PccHdrDevice
+     */
+    key?: string;
+    /**
+     * @type {string}
+     * @memberof PccHdrDevice
+     */
+    name?: string;
+    /**
+     * @type {string}
+     * @memberof PccHdrDevice
+     */
+    qualifier?: string;
+    /**
+     * All selected HDR playback passes for this device pool. (required)
+     * @type {number}
+     * @memberof PccHdrDevice
+     */
+    passes?: number;
+    /**
+     * Service-resolved verdict: negative findings outrank positive results. Null when no pass carries an HDR reading. (required)
+     * @type {PccDeviceHdrVerdict}
+     * @memberof PccHdrDevice
+     */
+    verdict?: PccDeviceHdrVerdict;
+    /**
+     * @type {PccHdrOutcomeCount[]}
+     * @memberof PccHdrDevice
+     */
+    outcomes?: PccHdrOutcomeCount[];
+    constructor(obj?: Partial<PccHdrDevice>);
+}
+export default PccHdrDevice;

package/dist/models/PccHdrDevice.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PccHdrDevice = void 0;
+const Mapper_1 = require("../common/Mapper");
+const PccDeviceHdrVerdict_1 = require("./PccDeviceHdrVerdict");
+const PccHdrOutcomeCount_1 = require("./PccHdrOutcomeCount");
+/**
+ * @export
+ * @class PccHdrDevice
+ */
+class PccHdrDevice {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.key = (0, Mapper_1.map)(obj.key);
+        this.name = (0, Mapper_1.map)(obj.name);
+        this.qualifier = (0, Mapper_1.map)(obj.qualifier);
+        this.passes = (0, Mapper_1.map)(obj.passes);
+        this.verdict = (0, Mapper_1.map)(obj.verdict, PccDeviceHdrVerdict_1.default);
+        this.outcomes = (0, Mapper_1.mapArray)(obj.outcomes, PccHdrOutcomeCount_1.default);
+    }
+}
+exports.PccHdrDevice = PccHdrDevice;
+exports.default = PccHdrDevice;

package/dist/models/PccHdrFinding.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @export
+ * @class PccHdrFinding
+ */
+export declare class PccHdrFinding {
+    /**
+     * The device pool, under the name the rest of the report shows it by. (required)
+     * @type {string}
+     * @memberof PccHdrFinding
+     */
+    device?: string;
+    /**
+     * @type {string}
+     * @memberof PccHdrFinding
+     */
+    codec?: string;
+    /**
+     * @type {string}
+     * @memberof PccHdrFinding
+     */
+    protection?: string;
+    /**
+     * What was found, in one paragraph. (required)
+     * @type {string}
+     * @memberof PccHdrFinding
+     */
+    sentence?: string;
+    constructor(obj?: Partial<PccHdrFinding>);
+}
+export default PccHdrFinding;

package/dist/models/PccHdrFinding.js

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

package/dist/models/PccHdrLegendEntry.d.ts

@@ -0,0 +1,39 @@
+import PccHdrConfidence from './PccHdrConfidence';
+/**
+ * @export
+ * @class PccHdrLegendEntry
+ */
+export declare class PccHdrLegendEntry {
+    /**
+     * The mark an HDR result wears on the cell. (required)
+     * @type {string}
+     * @memberof PccHdrLegendEntry
+     */
+    mark?: string;
+    /**
+     * The reader's word for it — `The frames really were HDR`, `The device claims HDR`, and so on. (required)
+     * @type {string}
+     * @memberof PccHdrLegendEntry
+     */
+    label?: string;
+    /**
+     * Which instrument established the picture, where anything did. (required)
+     * @type {PccHdrConfidence}
+     * @memberof PccHdrLegendEntry
+     */
+    confidence?: PccHdrConfidence;
+    /**
+     * What that mark establishes, and what it does not. (required)
+     * @type {string}
+     * @memberof PccHdrLegendEntry
+     */
+    sentence?: string;
+    /**
+     * Whether a result wearing this mark is one somebody should chase, which is not the same as how confident it is. (required)
+     * @type {boolean}
+     * @memberof PccHdrLegendEntry
+     */
+    actionable?: boolean;
+    constructor(obj?: Partial<PccHdrLegendEntry>);
+}
+export default PccHdrLegendEntry;

package/dist/models/PccHdrLegendEntry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PccHdrLegendEntry = void 0;
+const Mapper_1 = require("../common/Mapper");
+/**
+ * @export
+ * @class PccHdrLegendEntry
+ */
+class PccHdrLegendEntry {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.mark = (0, Mapper_1.map)(obj.mark);
+        this.label = (0, Mapper_1.map)(obj.label);
+        this.confidence = (0, Mapper_1.map)(obj.confidence);
+        this.sentence = (0, Mapper_1.map)(obj.sentence);
+        this.actionable = (0, Mapper_1.map)(obj.actionable);
+    }
+}
+exports.PccHdrLegendEntry = PccHdrLegendEntry;
+exports.default = PccHdrLegendEntry;

package/dist/models/PccHdrOutcome.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @export
+ * @enum {string}
+ */
+export declare enum PccHdrOutcome {
+    HDR = "hdr",
+    SDR = "sdr",
+    CLAIMED = "claimed",
+    DENIED = "denied",
+    UNESTABLISHED = "unestablished",
+    UNREPORTED = "unreported"
+}
+export default PccHdrOutcome;

package/dist/models/PccHdrOutcome.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PccHdrOutcome = void 0;
+/**
+ * @export
+ * @enum {string}
+ */
+var PccHdrOutcome;
+(function (PccHdrOutcome) {
+    PccHdrOutcome["HDR"] = "hdr";
+    PccHdrOutcome["SDR"] = "sdr";
+    PccHdrOutcome["CLAIMED"] = "claimed";
+    PccHdrOutcome["DENIED"] = "denied";
+    PccHdrOutcome["UNESTABLISHED"] = "unestablished";
+    PccHdrOutcome["UNREPORTED"] = "unreported";
+})(PccHdrOutcome || (exports.PccHdrOutcome = PccHdrOutcome = {}));
+exports.default = PccHdrOutcome;

package/dist/models/PccHdrOutcomeCount.d.ts

@@ -0,0 +1,32 @@
+import PccHdrConfidence from './PccHdrConfidence';
+import PccHdrOutcome from './PccHdrOutcome';
+/**
+ * @export
+ * @class PccHdrOutcomeCount
+ */
+export declare class PccHdrOutcomeCount {
+    /**
+     * @type {PccHdrOutcome}
+     * @memberof PccHdrOutcomeCount
+     */
+    outcome?: PccHdrOutcome;
+    /**
+     * Null only for unreported readings. Evidence includes both HDR and SDR outcomes. (required)
+     * @type {PccHdrConfidence}
+     * @memberof PccHdrOutcomeCount
+     */
+    confidence?: PccHdrConfidence;
+    /**
+     * @type {string}
+     * @memberof PccHdrOutcomeCount
+     */
+    label?: string;
+    /**
+     * Selected HDR playback passes with this outcome. All six outcomes sum to HDR passes. (required)
+     * @type {number}
+     * @memberof PccHdrOutcomeCount
+     */
+    cells?: number;
+    constructor(obj?: Partial<PccHdrOutcomeCount>);
+}
+export default PccHdrOutcomeCount;

package/dist/models/PccHdrOutcomeCount.js

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

package/dist/models/PccHdrShare.d.ts

@@ -0,0 +1,24 @@
+import PccHdrConfidence from './PccHdrConfidence';
+/**
+ * @export
+ * @class PccHdrShare
+ */
+export declare class PccHdrShare {
+    /**
+     * @type {PccHdrConfidence}
+     * @memberof PccHdrShare
+     */
+    confidence?: PccHdrConfidence;
+    /**
+     * @type {string}
+     * @memberof PccHdrShare
+     */
+    label?: string;
+    /**
+     * @type {number}
+     * @memberof PccHdrShare
+     */
+    cells?: number;
+    constructor(obj?: Partial<PccHdrShare>);
+}
+export default PccHdrShare;

package/dist/models/PccHdrShare.js

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

package/dist/models/PccHdrSummary.d.ts

@@ -0,0 +1,51 @@
+import PccHdrDevice from './PccHdrDevice';
+import PccHdrFinding from './PccHdrFinding';
+import PccHdrOutcomeCount from './PccHdrOutcomeCount';
+import PccHdrShare from './PccHdrShare';
+/**
+ * @export
+ * @class PccHdrSummary
+ */
+export declare class PccHdrSummary {
+    /**
+     * @type {PccHdrOutcomeCount[]}
+     * @memberof PccHdrSummary
+     */
+    outcomes?: PccHdrOutcomeCount[];
+    /**
+     * Selected device pools with at least one HDR playback pass. (required)
+     * @type {PccHdrDevice[]}
+     * @memberof PccHdrSummary
+     */
+    byDevice?: PccHdrDevice[];
+    /**
+     * @type {PccHdrShare[]}
+     * @memberof PccHdrSummary
+     */
+    shares?: PccHdrShare[];
+    /**
+     * HDR passes in the report. The picture question does not arise on a cell that failed. (required)
+     * @type {number}
+     * @memberof PccHdrSummary
+     */
+    passes?: number;
+    /**
+     * Passes carrying no reading at all, so a missing measurement never reads as a level of confidence. (required)
+     * @type {number}
+     * @memberof PccHdrSummary
+     */
+    unreported?: number;
+    /**
+     * Passes where some instrument answered — frames read, or the device's own word. The `evidence` and `claim` shares above, added together. (required)
+     * @type {number}
+     * @memberof PccHdrSummary
+     */
+    established?: number;
+    /**
+     * @type {PccHdrFinding[]}
+     * @memberof PccHdrSummary
+     */
+    findings?: PccHdrFinding[];
+    constructor(obj?: Partial<PccHdrSummary>);
+}
+export default PccHdrSummary;