@bitmovin/api-sdk 1.279.0 → 1.280.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.279.0',
+            'X-Api-Client-Version': '1.280.0',
             'Content-Type': 'application/json'
         };
         if (tenantOrgId) {

package/dist/models/AkamaiCloudRegion.d.ts

@@ -3,6 +3,7 @@
  * @enum {string}
  */
 export declare enum AkamaiCloudRegion {
+    AU_MEL = "AU_MEL",
     BR_GRU = "BR_GRU",
     ES_MAD = "ES_MAD",
     FR_PAR = "FR_PAR",

package/dist/models/AkamaiCloudRegion.js

@@ -7,6 +7,7 @@ exports.AkamaiCloudRegion = void 0;
  */
 var AkamaiCloudRegion;
 (function (AkamaiCloudRegion) {
+    AkamaiCloudRegion["AU_MEL"] = "AU_MEL";
     AkamaiCloudRegion["BR_GRU"] = "BR_GRU";
     AkamaiCloudRegion["ES_MAD"] = "ES_MAD";
     AkamaiCloudRegion["FR_PAR"] = "FR_PAR";

package/dist/models/Av1PerTitleConfiguration.d.ts

@@ -5,7 +5,7 @@ import PerTitleConfiguration from './PerTitleConfiguration';
  */
 export declare class Av1PerTitleConfiguration extends PerTitleConfiguration {
     /**
-     * Desired target quality of the highest representation expressed as CRF value
+     * Desired target quality of the highest representation expressed as a CRF value. If not set, it is derived from the content, starting from 34 for SDR content of at most FullHD and at most 30 fps; HFR (more than 30 fps) reduces it by 2; a resolution above FullHD reduces it by 2; HDR10 or HLG reduces it by 2; and Dolby Vision reduces it by 4 instead of the HDR10 reduction. These reductions are cumulative, so the lowest derived value is 26, for Dolby Vision 4K at 60 fps.
      * @type {number}
      * @memberof Av1PerTitleConfiguration
      */

package/dist/models/CloudRegion.d.ts

@@ -62,6 +62,7 @@ export declare enum CloudRegion {
     AZURE_US_SOUTH_CENTRAL = "AZURE_US_SOUTH_CENTRAL",
     AZURE_US_NORTH_CENTRAL = "AZURE_US_NORTH_CENTRAL",
     AZURE_UK_SOUTH = "AZURE_UK_SOUTH",
+    AKAMAI_AU_MEL = "AKAMAI_AU_MEL",
     AKAMAI_BR_GRU = "AKAMAI_BR_GRU",
     AKAMAI_ES_MAD = "AKAMAI_ES_MAD",
     AKAMAI_FR_PAR = "AKAMAI_FR_PAR",

package/dist/models/CloudRegion.js

@@ -66,6 +66,7 @@ var CloudRegion;
     CloudRegion["AZURE_US_SOUTH_CENTRAL"] = "AZURE_US_SOUTH_CENTRAL";
     CloudRegion["AZURE_US_NORTH_CENTRAL"] = "AZURE_US_NORTH_CENTRAL";
     CloudRegion["AZURE_UK_SOUTH"] = "AZURE_UK_SOUTH";
+    CloudRegion["AKAMAI_AU_MEL"] = "AKAMAI_AU_MEL";
     CloudRegion["AKAMAI_BR_GRU"] = "AKAMAI_BR_GRU";
     CloudRegion["AKAMAI_ES_MAD"] = "AKAMAI_ES_MAD";
     CloudRegion["AKAMAI_FR_PAR"] = "AKAMAI_FR_PAR";

package/dist/models/PccCell.d.ts

@@ -0,0 +1,75 @@
+import PccPicture from './PccPicture';
+import PccVerdict from './PccVerdict';
+/**
+ * @export
+ * @class PccCell
+ */
+export declare class PccCell {
+    /**
+     * What a combination says once every session that measured it has been read. Five of the nine answer for the measurement rather than for the device; `aboutTheDevice` says which, and folding those into \"not supported\" is how this data gets misread. (required)
+     * @type {PccVerdict}
+     * @memberof PccCell
+     */
+    verdict?: PccVerdict;
+    /**
+     * The reader's word for that verdict — `Supported`, `Not supported`, `Not measured`, and so on. Fewer words than there are verdicts: three of them read as `Not measured`. `legend` lists every word. (required)
+     * @type {string}
+     * @memberof PccCell
+     */
+    label?: string;
+    /**
+     * False where the verdict says something about the measurement rather than the device. (required)
+     * @type {boolean}
+     * @memberof PccCell
+     */
+    aboutTheDevice?: boolean;
+    /**
+     * The cell's whole account in one paragraph: the verdict, what agreed, the picture, the stream. (required)
+     * @type {string}
+     * @memberof PccCell
+     */
+    account?: string;
+    /**
+     * The grid's own mark for that verdict, which `legend` explains. (required)
+     * @type {string}
+     * @memberof PccCell
+     */
+    symbol?: string;
+    /**
+     * `3/4` where a session disagreed with the published verdict, and absent where none did.
+     * @type {string}
+     * @memberof PccCell
+     */
+    agreement?: string;
+    /**
+     * What the sessions that disagreed recorded, spelled out. Present only where `agreement` is.
+     * @type {string}
+     * @memberof PccCell
+     */
+    agreementAccount?: string;
+    /**
+     * @type {PccPicture}
+     * @memberof PccCell
+     */
+    picture?: PccPicture;
+    /**
+     * The sessions this verdict was taken from. Quote one to Bitmovin support and the measurement behind this cell can be looked up, for as long as the fleet still holds it. (required)
+     * @type {string[]}
+     * @memberof PccCell
+     */
+    agreeingSessionIds?: string[];
+    /**
+     * How many sessions recorded anything at all for this combination. (required)
+     * @type {number}
+     * @memberof PccCell
+     */
+    resultSessions?: number;
+    /**
+     * Evidence excluded by the start date or session limit, including pools with no included sessions.
+     * @type {string}
+     * @memberof PccCell
+     */
+    recency?: string;
+    constructor(obj?: Partial<PccCell>);
+}
+export default PccCell;

package/dist/models/PccCell.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PccCell = void 0;
+const Mapper_1 = require("../common/Mapper");
+const PccPicture_1 = require("./PccPicture");
+/**
+ * @export
+ * @class PccCell
+ */
+class PccCell {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.verdict = (0, Mapper_1.map)(obj.verdict);
+        this.label = (0, Mapper_1.map)(obj.label);
+        this.aboutTheDevice = (0, Mapper_1.map)(obj.aboutTheDevice);
+        this.account = (0, Mapper_1.map)(obj.account);
+        this.symbol = (0, Mapper_1.map)(obj.symbol);
+        this.agreement = (0, Mapper_1.map)(obj.agreement);
+        this.agreementAccount = (0, Mapper_1.map)(obj.agreementAccount);
+        this.picture = (0, Mapper_1.map)(obj.picture, PccPicture_1.default);
+        this.agreeingSessionIds = (0, Mapper_1.mapArray)(obj.agreeingSessionIds);
+        this.resultSessions = (0, Mapper_1.map)(obj.resultSessions);
+        this.recency = (0, Mapper_1.map)(obj.recency);
+    }
+}
+exports.PccCell = PccCell;
+exports.default = PccCell;

package/dist/models/PccCodecDeviceTypeReach.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @export
+ * @class PccCodecDeviceTypeReach
+ */
+export declare class PccCodecDeviceTypeReach {
+    /**
+     * @type {string}
+     * @memberof PccCodecDeviceTypeReach
+     */
+    deviceType?: string;
+    /**
+     * Distinct selected device pools that played this codec. (required)
+     * @type {number}
+     * @memberof PccCodecDeviceTypeReach
+     */
+    played?: number;
+    /**
+     * Distinct selected pools that answered about this codec. A protection-only refusal is excluded. (required)
+     * @type {number}
+     * @memberof PccCodecDeviceTypeReach
+     */
+    measured?: number;
+    constructor(obj?: Partial<PccCodecDeviceTypeReach>);
+}
+export default PccCodecDeviceTypeReach;

package/dist/models/PccCodecDeviceTypeReach.js

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

package/dist/models/PccCodecReach.d.ts

@@ -0,0 +1,19 @@
+import PccCodecDeviceTypeReach from './PccCodecDeviceTypeReach';
+/**
+ * @export
+ * @class PccCodecReach
+ */
+export declare class PccCodecReach {
+    /**
+     * @type {string}
+     * @memberof PccCodecReach
+     */
+    codec?: string;
+    /**
+     * @type {PccCodecDeviceTypeReach[]}
+     * @memberof PccCodecReach
+     */
+    byDeviceType?: PccCodecDeviceTypeReach[];
+    constructor(obj?: Partial<PccCodecReach>);
+}
+export default PccCodecReach;

package/dist/models/PccCodecReach.js

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

package/dist/models/PccCombination.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @export
+ * @class PccCombination
+ */
+export declare class PccCombination {
+    /**
+     * The codec, as the shared contract spells it. (required)
+     * @type {string}
+     * @memberof PccCombination
+     */
+    codec?: string;
+    /**
+     * The content protection, as the shared contract spells it. (required)
+     * @type {string}
+     * @memberof PccCombination
+     */
+    protection?: string;
+    /**
+     * The column heading, spelled the way a reader reads it rather than the way the catalogue spells it. (required)
+     * @type {string}
+     * @memberof PccCombination
+     */
+    label?: string;
+    /**
+     * Whether this column's stream is HDR. Read it here rather than out of the codec name: not every HDR codec spells `hdr10`, and the Dolby Vision ones never do. (required)
+     * @type {boolean}
+     * @memberof PccCombination
+     */
+    hdr?: boolean;
+    constructor(obj?: Partial<PccCombination>);
+}
+export default PccCombination;

package/dist/models/PccCombination.js

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

package/dist/models/PccCombinationEvidence.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @export
+ * @class PccCombinationEvidence
+ */
+export declare class PccCombinationEvidence {
+    /**
+     * The codec, as the shared contract spells it. (required)
+     * @type {string}
+     * @memberof PccCombinationEvidence
+     */
+    codec?: string;
+    /**
+     * The content protection, as the shared contract spells it. (required)
+     * @type {string}
+     * @memberof PccCombinationEvidence
+     */
+    protection?: string;
+    /**
+     * Device pools that played it, which is what proves the stream behind it works at all. (required)
+     * @type {number}
+     * @memberof PccCombinationEvidence
+     */
+    playedBy?: number;
+    /**
+     * Device pools that reported support for it and then failed to play it. (required)
+     * @type {number}
+     * @memberof PccCombinationEvidence
+     */
+    claimedNotPlayedBy?: number;
+    /**
+     * Device pools that produced an answer either way. (required)
+     * @type {number}
+     * @memberof PccCombinationEvidence
+     */
+    measuredBy?: number;
+    /**
+     * No conformant stream can exist for this pairing, so it is neither gap nor result. (required)
+     * @type {boolean}
+     * @memberof PccCombinationEvidence
+     */
+    notApplicable?: boolean;
+    /**
+     * Hosts that served its stream. A host only — never a path and never a URL. (required)
+     * @type {string[]}
+     * @memberof PccCombinationEvidence
+     */
+    assetHosts?: string[];
+    /**
+     * Hosts that licensed it. A separate axis from the one above: without both, a device refusing a codec cannot be told from a stream that stopped being served. (required)
+     * @type {string[]}
+     * @memberof PccCombinationEvidence
+     */
+    licenseServers?: string[];
+    constructor(obj?: Partial<PccCombinationEvidence>);
+}
+export default PccCombinationEvidence;

package/dist/models/PccCombinationEvidence.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PccCombinationEvidence = void 0;
+const Mapper_1 = require("../common/Mapper");
+/**
+ * @export
+ * @class PccCombinationEvidence
+ */
+class PccCombinationEvidence {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.codec = (0, Mapper_1.map)(obj.codec);
+        this.protection = (0, Mapper_1.map)(obj.protection);
+        this.playedBy = (0, Mapper_1.map)(obj.playedBy);
+        this.claimedNotPlayedBy = (0, Mapper_1.map)(obj.claimedNotPlayedBy);
+        this.measuredBy = (0, Mapper_1.map)(obj.measuredBy);
+        this.notApplicable = (0, Mapper_1.map)(obj.notApplicable);
+        this.assetHosts = (0, Mapper_1.mapArray)(obj.assetHosts);
+        this.licenseServers = (0, Mapper_1.mapArray)(obj.licenseServers);
+    }
+}
+exports.PccCombinationEvidence = PccCombinationEvidence;
+exports.default = PccCombinationEvidence;

package/dist/models/PccCompatibilityMatrix.d.ts

@@ -0,0 +1,83 @@
+import PccCombination from './PccCombination';
+import PccCoverage from './PccCoverage';
+import PccDevice from './PccDevice';
+import PccHdrLegendEntry from './PccHdrLegendEntry';
+import PccReportView from './PccReportView';
+import PccSummary from './PccSummary';
+import PccVerdictLegendEntry from './PccVerdictLegendEntry';
+/**
+ * @export
+ * @class PccCompatibilityMatrix
+ */
+export declare class PccCompatibilityMatrix {
+    /**
+     * The effective selection already applied to this matrix, its summary and coverage. (required)
+     * @type {PccReportView}
+     * @memberof PccCompatibilityMatrix
+     */
+    view?: PccReportView;
+    /**
+     * When this report was assembled from what had been measured by then. (required)
+     * @type {string}
+     * @memberof PccCompatibilityMatrix
+     */
+    assembledAt?: string;
+    /**
+     * Every Bitmovin Player version that measured any device here. More than one means the measurement spanned a player release, and support is a property of the player and the device together. (required)
+     * @type {string[]}
+     * @memberof PccCompatibilityMatrix
+     */
+    playerVersions?: string[];
+    /**
+     * UUIDs of matching runs whose job metadata was read, including runs with no included session evidence. Never run names. Quote one to Bitmovin support while the fleet still holds it. The count says nothing about coverage. (required)
+     * @type {string[]}
+     * @memberof PccCompatibilityMatrix
+     */
+    runIds?: string[];
+    /**
+     * Inclusive run creation instant in UTC used by this generation, or null for no cutoff. Legacy dates mean midnight UTC. Changing the held cutoff does not alter this report. (required)
+     * @type {Date}
+     * @memberof PccCompatibilityMatrix
+     */
+    startDate?: Date;
+    /**
+     * Maximum sessions read per pool by this generation. Null for reports produced before a limit was recorded. (required)
+     * @type {number}
+     * @memberof PccCompatibilityMatrix
+     */
+    sessionLimit?: number;
+    /**
+     * @type {PccCoverage}
+     * @memberof PccCompatibilityMatrix
+     */
+    coverage?: PccCoverage;
+    /**
+     * Every verdict mark and its wording, so the grid reads without this service's source. (required)
+     * @type {PccVerdictLegendEntry[]}
+     * @memberof PccCompatibilityMatrix
+     */
+    legend?: PccVerdictLegendEntry[];
+    /**
+     * The same for the marks an HDR result wears. (required)
+     * @type {PccHdrLegendEntry[]}
+     * @memberof PccCompatibilityMatrix
+     */
+    hdrLegend?: PccHdrLegendEntry[];
+    /**
+     * @type {PccCombination[]}
+     * @memberof PccCompatibilityMatrix
+     */
+    combinations?: PccCombination[];
+    /**
+     * @type {PccDevice[]}
+     * @memberof PccCompatibilityMatrix
+     */
+    devices?: PccDevice[];
+    /**
+     * @type {PccSummary}
+     * @memberof PccCompatibilityMatrix
+     */
+    summary?: PccSummary;
+    constructor(obj?: Partial<PccCompatibilityMatrix>);
+}
+export default PccCompatibilityMatrix;

package/dist/models/PccCompatibilityMatrix.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PccCompatibilityMatrix = void 0;
+const Mapper_1 = require("../common/Mapper");
+const PccCombination_1 = require("./PccCombination");
+const PccCoverage_1 = require("./PccCoverage");
+const PccDevice_1 = require("./PccDevice");
+const PccHdrLegendEntry_1 = require("./PccHdrLegendEntry");
+const PccReportView_1 = require("./PccReportView");
+const PccSummary_1 = require("./PccSummary");
+const PccVerdictLegendEntry_1 = require("./PccVerdictLegendEntry");
+/**
+ * @export
+ * @class PccCompatibilityMatrix
+ */
+class PccCompatibilityMatrix {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.view = (0, Mapper_1.map)(obj.view, PccReportView_1.default);
+        this.assembledAt = (0, Mapper_1.map)(obj.assembledAt);
+        this.playerVersions = (0, Mapper_1.mapArray)(obj.playerVersions);
+        this.runIds = (0, Mapper_1.mapArray)(obj.runIds);
+        this.startDate = (0, Mapper_1.map)(obj.startDate, Date);
+        this.sessionLimit = (0, Mapper_1.map)(obj.sessionLimit);
+        this.coverage = (0, Mapper_1.map)(obj.coverage, PccCoverage_1.default);
+        this.legend = (0, Mapper_1.mapArray)(obj.legend, PccVerdictLegendEntry_1.default);
+        this.hdrLegend = (0, Mapper_1.mapArray)(obj.hdrLegend, PccHdrLegendEntry_1.default);
+        this.combinations = (0, Mapper_1.mapArray)(obj.combinations, PccCombination_1.default);
+        this.devices = (0, Mapper_1.mapArray)(obj.devices, PccDevice_1.default);
+        this.summary = (0, Mapper_1.map)(obj.summary, PccSummary_1.default);
+    }
+}
+exports.PccCompatibilityMatrix = PccCompatibilityMatrix;
+exports.default = PccCompatibilityMatrix;

package/dist/models/PccCoverage.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @export
+ * @class PccCoverage
+ */
+export declare class PccCoverage {
+    /**
+     * Distinct pools in the held measurement before any view exclusions. (required)
+     * @type {number}
+     * @memberof PccCoverage
+     */
+    devicesBeforeView?: number;
+    /**
+     * Pools omitted by the device filter after prerelease exclusions. Each omitted pool is counted once, in prerelease, device-filter, then reported-only order. (required)
+     * @type {number}
+     * @memberof PccCoverage
+     */
+    devicesExcludedByDeviceFilter?: number;
+    /**
+     * Pools omitted by reportedOnly because no selected cell answers about the device, after prerelease and device-filter exclusions. (required)
+     * @type {number}
+     * @memberof PccCoverage
+     */
+    devicesExcludedAsUnreported?: number;
+    /**
+     * Distinct pools omitted because all recorded browser evidence is pre-release. Zero when includePrerelease is true. Unknown browser identities do not cause prerelease exclusion. Row coverage and summaries describe the retained pools. (required)
+     * @type {number}
+     * @memberof PccCoverage
+     */
+    devicesExcludedAsPrerelease?: number;
+    /**
+     * @type {number}
+     * @memberof PccCoverage
+     */
+    devices?: number;
+    /**
+     * Pools with no included sessions. Present in the report as unmeasured, including when the start date excluded all evidence. (required)
+     * @type {number}
+     * @memberof PccCoverage
+     */
+    devicesWithNoSession?: number;
+    /**
+     * Pools every one of whose sessions came from one physical machine — a claim about that machine, not the model. (required)
+     * @type {number}
+     * @memberof PccCoverage
+     */
+    devicesOnOneUnit?: number;
+    /**
+     * Pools no naming rule recognised, published under the stated placeholder. Counted here so a reader can tell how much of the fleet this report cannot name rather than discovering it row by row. (required)
+     * @type {number}
+     * @memberof PccCoverage
+     */
+    devicesUnderPlaceholderName?: number;
+    /**
+     * Cells whose verdict rests on a single session. (required)
+     * @type {number}
+     * @memberof PccCoverage
+     */
+    cellsOnOneSession?: number;
+    /**
+     * Jobs the fleet could not attribute to any pool, so no row of this report accounts for them. (required)
+     * @type {number}
+     * @memberof PccCoverage
+     */
+    unattributableJobs?: number;
+    /**
+     * Jobs that had not finished when this was assembled. Their pools carry nothing measured. (required)
+     * @type {number}
+     * @memberof PccCoverage
+     */
+    unsettledJobs?: number;
+    /**
+     * Pools with sessions excluded by the start date or session limit, including those with no included evidence. (required)
+     * @type {number}
+     * @memberof PccCoverage
+     */
+    devicesOnRecentEvidence?: number;
+    constructor(obj?: Partial<PccCoverage>);
+}
+export default PccCoverage;

package/dist/models/PccCoverage.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PccCoverage = void 0;
+const Mapper_1 = require("../common/Mapper");
+/**
+ * @export
+ * @class PccCoverage
+ */
+class PccCoverage {
+    constructor(obj) {
+        if (!obj) {
+            return;
+        }
+        this.devicesBeforeView = (0, Mapper_1.map)(obj.devicesBeforeView);
+        this.devicesExcludedByDeviceFilter = (0, Mapper_1.map)(obj.devicesExcludedByDeviceFilter);
+        this.devicesExcludedAsUnreported = (0, Mapper_1.map)(obj.devicesExcludedAsUnreported);
+        this.devicesExcludedAsPrerelease = (0, Mapper_1.map)(obj.devicesExcludedAsPrerelease);
+        this.devices = (0, Mapper_1.map)(obj.devices);
+        this.devicesWithNoSession = (0, Mapper_1.map)(obj.devicesWithNoSession);
+        this.devicesOnOneUnit = (0, Mapper_1.map)(obj.devicesOnOneUnit);
+        this.devicesUnderPlaceholderName = (0, Mapper_1.map)(obj.devicesUnderPlaceholderName);
+        this.cellsOnOneSession = (0, Mapper_1.map)(obj.cellsOnOneSession);
+        this.unattributableJobs = (0, Mapper_1.map)(obj.unattributableJobs);
+        this.unsettledJobs = (0, Mapper_1.map)(obj.unsettledJobs);
+        this.devicesOnRecentEvidence = (0, Mapper_1.map)(obj.devicesOnRecentEvidence);
+    }
+}
+exports.PccCoverage = PccCoverage;
+exports.default = PccCoverage;

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;