@arrowsphere/api-client 3.16.0-rc.1 → 3.17.0-rc.1

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.16.0] - 2022-11-09
+
+### Changed
+
+- Add endpoint license auto-renew on/off
+
 ## [3.15.1] - 2022-10-28
 
 ### Changed

package/build/index.d.ts

@@ -13,6 +13,7 @@ export * from './orders/';
 export * from './publicApiClient';
 export * from './publicGraphQLClient';
 export * from './shared/';
+export * from './standards/';
 export * from './subscriptions/';
 export { ContactInformation };
 import * as ContactInformation from './contact';

package/build/index.js

@@ -38,6 +38,7 @@ __exportStar(require("./orders/"), exports);
 __exportStar(require("./publicApiClient"), exports);
 __exportStar(require("./publicGraphQLClient"), exports);
 __exportStar(require("./shared/"), exports);
+__exportStar(require("./standards/"), exports);
 __exportStar(require("./subscriptions/"), exports);
 const ContactInformation = __importStar(require("./contact"));
 exports.ContactInformation = ContactInformation;

package/build/publicApiClient.d.ts

@@ -7,6 +7,7 @@ import { OrdersClient } from './orders';
 import { ContactClient } from './contact';
 import { CampaignClient } from './campaign';
 import { ConsumptionClient } from './consumption';
+import { StandardsClient } from './standards/standardsClient';
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -53,5 +54,6 @@ export declare class PublicApiClient extends AbstractClient {
      */
     getCampaignClient(): CampaignClient;
     getConsumptionClient(): ConsumptionClient;
+    getStandardsClient(): StandardsClient;
 }
 export default PublicApiClient;

package/build/publicApiClient.js

@@ -10,6 +10,7 @@ const orders_1 = require("./orders");
 const contact_1 = require("./contact");
 const campaign_1 = require("./campaign");
 const consumption_1 = require("./consumption");
+const standardsClient_1 = require("./standards/standardsClient");
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -103,6 +104,12 @@ class PublicApiClient extends abstractClient_1.AbstractClient {
             .setApiKey(this.apiKey)
             .setHeaders(this.headers);
     }
+    getStandardsClient() {
+        return new standardsClient_1.StandardsClient(this.client)
+            .setUrl(this.url)
+            .setApiKey(this.apiKey)
+            .setHeaders(this.headers);
+    }
 }
 exports.PublicApiClient = PublicApiClient;
 exports.default = PublicApiClient;

package/build/standards/entities/checks/checks.d.ts

@@ -0,0 +1,17 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { SecurityChecks, SecurityChecksType } from './securityChecks';
+export declare enum ChecksFields {
+    COLUMN_CHECKS = "checks",
+    COLUMN_UPDATED_AT = "updatedAt"
+}
+export declare type ChecksType = {
+    [ChecksFields.COLUMN_CHECKS]: Array<SecurityChecksType>;
+    [ChecksFields.COLUMN_UPDATED_AT]: string;
+};
+export declare class Checks extends AbstractEntity<ChecksType> {
+    #private;
+    constructor(checksDataInput: ChecksType);
+    get checks(): Array<SecurityChecks>;
+    get updatedAt(): string;
+    toJSON(): ChecksType;
+}

package/build/standards/entities/checks/checks.js

@@ -0,0 +1,48 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _checks, _updatedAt;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Checks = exports.ChecksFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const securityChecks_1 = require("./securityChecks");
+var ChecksFields;
+(function (ChecksFields) {
+    ChecksFields["COLUMN_CHECKS"] = "checks";
+    ChecksFields["COLUMN_UPDATED_AT"] = "updatedAt";
+})(ChecksFields = exports.ChecksFields || (exports.ChecksFields = {}));
+class Checks extends abstractEntity_1.AbstractEntity {
+    constructor(checksDataInput) {
+        super(checksDataInput);
+        _checks.set(this, void 0);
+        _updatedAt.set(this, void 0);
+        __classPrivateFieldSet(this, _checks, checksDataInput[ChecksFields.COLUMN_CHECKS].map((securityChecks) => new securityChecks_1.SecurityChecks(securityChecks)));
+        __classPrivateFieldSet(this, _updatedAt, checksDataInput[ChecksFields.COLUMN_UPDATED_AT]);
+    }
+    get checks() {
+        return __classPrivateFieldGet(this, _checks);
+    }
+    get updatedAt() {
+        return __classPrivateFieldGet(this, _updatedAt);
+    }
+    toJSON() {
+        return {
+            [ChecksFields.COLUMN_CHECKS]: this.checks.map((securityChecks) => securityChecks.toJSON()),
+            [ChecksFields.COLUMN_UPDATED_AT]: this.updatedAt,
+        };
+    }
+}
+exports.Checks = Checks;
+_checks = new WeakMap(), _updatedAt = new WeakMap();
+//# sourceMappingURL=checks.js.map

package/build/standards/entities/checks/securityChecks.d.ts

@@ -0,0 +1,37 @@
+import { AbstractEntity } from '../../../abstractEntity';
+export declare enum SecurityChecksFields {
+    COLUMN_DESCRIPTION = "description",
+    COLUMN_FLAGGED = "flagged",
+    COLUMN_IS_FAILED = "isFailed",
+    COLUMN_METADATA = "metadata",
+    COLUMN_NAME = "name",
+    COLUMN_PROCESSED = "processed",
+    COLUMN_REFERENCE = "reference",
+    COLUMN_SCORE = "score",
+    COLUMN_SEVERITY = "severity"
+}
+export declare type SecurityChecksType = {
+    [SecurityChecksFields.COLUMN_DESCRIPTION]: string;
+    [SecurityChecksFields.COLUMN_FLAGGED]: number;
+    [SecurityChecksFields.COLUMN_IS_FAILED]: boolean;
+    [SecurityChecksFields.COLUMN_METADATA]: Array<string>;
+    [SecurityChecksFields.COLUMN_NAME]: string;
+    [SecurityChecksFields.COLUMN_PROCESSED]: number;
+    [SecurityChecksFields.COLUMN_REFERENCE]: string;
+    [SecurityChecksFields.COLUMN_SCORE]: number;
+    [SecurityChecksFields.COLUMN_SEVERITY]: string;
+};
+export declare class SecurityChecks extends AbstractEntity<SecurityChecksType> {
+    #private;
+    constructor(securityChecksDataInput: SecurityChecksType);
+    get description(): string;
+    get flagged(): number;
+    get isFailed(): boolean;
+    get metadata(): Array<string>;
+    get name(): string;
+    get processed(): number;
+    get reference(): string;
+    get score(): number;
+    get severity(): string;
+    toJSON(): SecurityChecksType;
+}

package/build/standards/entities/checks/securityChecks.js

@@ -0,0 +1,96 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _description, _flagged, _isFailed, _metadata, _name, _processed, _reference, _score, _severity;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityChecks = exports.SecurityChecksFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var SecurityChecksFields;
+(function (SecurityChecksFields) {
+    SecurityChecksFields["COLUMN_DESCRIPTION"] = "description";
+    SecurityChecksFields["COLUMN_FLAGGED"] = "flagged";
+    SecurityChecksFields["COLUMN_IS_FAILED"] = "isFailed";
+    SecurityChecksFields["COLUMN_METADATA"] = "metadata";
+    SecurityChecksFields["COLUMN_NAME"] = "name";
+    SecurityChecksFields["COLUMN_PROCESSED"] = "processed";
+    SecurityChecksFields["COLUMN_REFERENCE"] = "reference";
+    SecurityChecksFields["COLUMN_SCORE"] = "score";
+    SecurityChecksFields["COLUMN_SEVERITY"] = "severity";
+})(SecurityChecksFields = exports.SecurityChecksFields || (exports.SecurityChecksFields = {}));
+class SecurityChecks extends abstractEntity_1.AbstractEntity {
+    constructor(securityChecksDataInput) {
+        super(securityChecksDataInput);
+        _description.set(this, void 0);
+        _flagged.set(this, void 0);
+        _isFailed.set(this, void 0);
+        _metadata.set(this, void 0);
+        _name.set(this, void 0);
+        _processed.set(this, void 0);
+        _reference.set(this, void 0);
+        _score.set(this, void 0);
+        _severity.set(this, void 0);
+        __classPrivateFieldSet(this, _description, securityChecksDataInput[SecurityChecksFields.COLUMN_DESCRIPTION]);
+        __classPrivateFieldSet(this, _flagged, securityChecksDataInput[SecurityChecksFields.COLUMN_FLAGGED]);
+        __classPrivateFieldSet(this, _isFailed, securityChecksDataInput[SecurityChecksFields.COLUMN_IS_FAILED]);
+        __classPrivateFieldSet(this, _metadata, securityChecksDataInput[SecurityChecksFields.COLUMN_METADATA]);
+        __classPrivateFieldSet(this, _name, securityChecksDataInput[SecurityChecksFields.COLUMN_NAME]);
+        __classPrivateFieldSet(this, _processed, securityChecksDataInput[SecurityChecksFields.COLUMN_PROCESSED]);
+        __classPrivateFieldSet(this, _reference, securityChecksDataInput[SecurityChecksFields.COLUMN_REFERENCE]);
+        __classPrivateFieldSet(this, _score, securityChecksDataInput[SecurityChecksFields.COLUMN_SCORE]);
+        __classPrivateFieldSet(this, _severity, securityChecksDataInput[SecurityChecksFields.COLUMN_SEVERITY]);
+    }
+    get description() {
+        return __classPrivateFieldGet(this, _description);
+    }
+    get flagged() {
+        return __classPrivateFieldGet(this, _flagged);
+    }
+    get isFailed() {
+        return __classPrivateFieldGet(this, _isFailed);
+    }
+    get metadata() {
+        return __classPrivateFieldGet(this, _metadata);
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _name);
+    }
+    get processed() {
+        return __classPrivateFieldGet(this, _processed);
+    }
+    get reference() {
+        return __classPrivateFieldGet(this, _reference);
+    }
+    get score() {
+        return __classPrivateFieldGet(this, _score);
+    }
+    get severity() {
+        return __classPrivateFieldGet(this, _severity);
+    }
+    toJSON() {
+        return {
+            [SecurityChecksFields.COLUMN_DESCRIPTION]: this.description,
+            [SecurityChecksFields.COLUMN_FLAGGED]: this.flagged,
+            [SecurityChecksFields.COLUMN_IS_FAILED]: this.isFailed,
+            [SecurityChecksFields.COLUMN_METADATA]: this.metadata,
+            [SecurityChecksFields.COLUMN_NAME]: this.name,
+            [SecurityChecksFields.COLUMN_PROCESSED]: this.processed,
+            [SecurityChecksFields.COLUMN_REFERENCE]: this.reference,
+            [SecurityChecksFields.COLUMN_SCORE]: this.score,
+            [SecurityChecksFields.COLUMN_SEVERITY]: this.severity,
+        };
+    }
+}
+exports.SecurityChecks = SecurityChecks;
+_description = new WeakMap(), _flagged = new WeakMap(), _isFailed = new WeakMap(), _metadata = new WeakMap(), _name = new WeakMap(), _processed = new WeakMap(), _reference = new WeakMap(), _score = new WeakMap(), _severity = new WeakMap();
+//# sourceMappingURL=securityChecks.js.map

package/build/standards/entities/resources/resources.d.ts

@@ -0,0 +1,26 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { SecurityResources, SecurityResourcesType } from './securityResources';
+export declare enum ResourcesFields {
+    COLUMN_DESCRIPTION = "description",
+    COLUMN_METADATA = "metadata",
+    COLUMN_NAME = "name",
+    COLUMN_RESOURCES = "resources",
+    COLUMN_UPDATED_AT = "updatedAt"
+}
+export declare type ResourcesType = {
+    [ResourcesFields.COLUMN_DESCRIPTION]: string;
+    [ResourcesFields.COLUMN_METADATA]: Array<string>;
+    [ResourcesFields.COLUMN_NAME]: string;
+    [ResourcesFields.COLUMN_RESOURCES]: Array<SecurityResourcesType>;
+    [ResourcesFields.COLUMN_UPDATED_AT]: string;
+};
+export declare class Resources extends AbstractEntity<ResourcesType> {
+    #private;
+    constructor(resources: ResourcesType);
+    get description(): string;
+    get metadata(): Array<string>;
+    get name(): string;
+    get resources(): Array<SecurityResources>;
+    get updatedAt(): string;
+    toJSON(): ResourcesType;
+}

package/build/standards/entities/resources/resources.js

@@ -0,0 +1,69 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _description, _metadata, _name, _resources, _updatedAt;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resources = exports.ResourcesFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const securityResources_1 = require("./securityResources");
+var ResourcesFields;
+(function (ResourcesFields) {
+    ResourcesFields["COLUMN_DESCRIPTION"] = "description";
+    ResourcesFields["COLUMN_METADATA"] = "metadata";
+    ResourcesFields["COLUMN_NAME"] = "name";
+    ResourcesFields["COLUMN_RESOURCES"] = "resources";
+    ResourcesFields["COLUMN_UPDATED_AT"] = "updatedAt";
+})(ResourcesFields = exports.ResourcesFields || (exports.ResourcesFields = {}));
+class Resources extends abstractEntity_1.AbstractEntity {
+    constructor(resources) {
+        super(resources);
+        _description.set(this, void 0);
+        _metadata.set(this, void 0);
+        _name.set(this, void 0);
+        _resources.set(this, void 0);
+        _updatedAt.set(this, void 0);
+        __classPrivateFieldSet(this, _description, resources[ResourcesFields.COLUMN_DESCRIPTION]);
+        __classPrivateFieldSet(this, _metadata, resources[ResourcesFields.COLUMN_METADATA]);
+        __classPrivateFieldSet(this, _name, resources[ResourcesFields.COLUMN_NAME]);
+        __classPrivateFieldSet(this, _resources, resources[ResourcesFields.COLUMN_RESOURCES].map((securityResources) => new securityResources_1.SecurityResources(securityResources)));
+        __classPrivateFieldSet(this, _updatedAt, resources[ResourcesFields.COLUMN_UPDATED_AT]);
+    }
+    get description() {
+        return __classPrivateFieldGet(this, _description);
+    }
+    get metadata() {
+        return __classPrivateFieldGet(this, _metadata);
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _name);
+    }
+    get resources() {
+        return __classPrivateFieldGet(this, _resources);
+    }
+    get updatedAt() {
+        return __classPrivateFieldGet(this, _updatedAt);
+    }
+    toJSON() {
+        return {
+            [ResourcesFields.COLUMN_DESCRIPTION]: this.description,
+            [ResourcesFields.COLUMN_METADATA]: this.metadata,
+            [ResourcesFields.COLUMN_NAME]: this.name,
+            [ResourcesFields.COLUMN_RESOURCES]: this.resources.map((securityResources) => securityResources.toJSON()),
+            [ResourcesFields.COLUMN_UPDATED_AT]: this.updatedAt,
+        };
+    }
+}
+exports.Resources = Resources;
+_description = new WeakMap(), _metadata = new WeakMap(), _name = new WeakMap(), _resources = new WeakMap(), _updatedAt = new WeakMap();
+//# sourceMappingURL=resources.js.map

package/build/standards/entities/resources/securityResources.d.ts

@@ -0,0 +1,16 @@
+import { AbstractEntity } from '../../../abstractEntity';
+export declare enum SecurityResourcesFields {
+    COLUMN_STATUS = "status",
+    COLUMN_VALUES = "values"
+}
+export declare type SecurityResourcesType = {
+    [SecurityResourcesFields.COLUMN_STATUS]: string;
+    [SecurityResourcesFields.COLUMN_VALUES]: Array<string>;
+};
+export declare class SecurityResources extends AbstractEntity<SecurityResourcesType> {
+    #private;
+    constructor(securityResources: SecurityResourcesType);
+    get status(): string;
+    get values(): Array<string>;
+    toJSON(): SecurityResourcesType;
+}

package/build/standards/entities/resources/securityResources.js

@@ -0,0 +1,47 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _status, _values;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityResources = exports.SecurityResourcesFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var SecurityResourcesFields;
+(function (SecurityResourcesFields) {
+    SecurityResourcesFields["COLUMN_STATUS"] = "status";
+    SecurityResourcesFields["COLUMN_VALUES"] = "values";
+})(SecurityResourcesFields = exports.SecurityResourcesFields || (exports.SecurityResourcesFields = {}));
+class SecurityResources extends abstractEntity_1.AbstractEntity {
+    constructor(securityResources) {
+        super(securityResources);
+        _status.set(this, void 0);
+        _values.set(this, void 0);
+        __classPrivateFieldSet(this, _status, securityResources[SecurityResourcesFields.COLUMN_STATUS]);
+        __classPrivateFieldSet(this, _values, securityResources[SecurityResourcesFields.COLUMN_VALUES]);
+    }
+    get status() {
+        return __classPrivateFieldGet(this, _status);
+    }
+    get values() {
+        return __classPrivateFieldGet(this, _values);
+    }
+    toJSON() {
+        return {
+            [SecurityResourcesFields.COLUMN_STATUS]: this.status,
+            [SecurityResourcesFields.COLUMN_VALUES]: this.values,
+        };
+    }
+}
+exports.SecurityResources = SecurityResources;
+_status = new WeakMap(), _values = new WeakMap();
+//# sourceMappingURL=securityResources.js.map

package/build/standards/entities/standards/securityStandards.d.ts

@@ -0,0 +1,28 @@
+import { AbstractEntity } from '../../../abstractEntity';
+export declare enum SecurityStandardsFields {
+    COLUMN_FAILED = "failed",
+    COLUMN_NAME = "name",
+    COLUMN_PASSED = "passed",
+    COLUMN_REFERENCE = "reference",
+    COLUMN_SCORE = "score",
+    COLUMN_TOTAL = "total"
+}
+export declare type SecurityStandardsType = {
+    [SecurityStandardsFields.COLUMN_FAILED]: number;
+    [SecurityStandardsFields.COLUMN_NAME]: string;
+    [SecurityStandardsFields.COLUMN_PASSED]: number;
+    [SecurityStandardsFields.COLUMN_REFERENCE]: string;
+    [SecurityStandardsFields.COLUMN_SCORE]: number;
+    [SecurityStandardsFields.COLUMN_TOTAL]: number;
+};
+export declare class SecurityStandards extends AbstractEntity<SecurityStandardsType> {
+    #private;
+    constructor(standardsSecurityDataInput: SecurityStandardsType);
+    get failed(): number;
+    get name(): string;
+    get passed(): number;
+    get reference(): string;
+    get score(): number;
+    get total(): number;
+    toJSON(): SecurityStandardsType;
+}

package/build/standards/entities/standards/securityStandards.js

@@ -0,0 +1,75 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _failed, _name, _passed, _reference, _score, _total;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityStandards = exports.SecurityStandardsFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var SecurityStandardsFields;
+(function (SecurityStandardsFields) {
+    SecurityStandardsFields["COLUMN_FAILED"] = "failed";
+    SecurityStandardsFields["COLUMN_NAME"] = "name";
+    SecurityStandardsFields["COLUMN_PASSED"] = "passed";
+    SecurityStandardsFields["COLUMN_REFERENCE"] = "reference";
+    SecurityStandardsFields["COLUMN_SCORE"] = "score";
+    SecurityStandardsFields["COLUMN_TOTAL"] = "total";
+})(SecurityStandardsFields = exports.SecurityStandardsFields || (exports.SecurityStandardsFields = {}));
+class SecurityStandards extends abstractEntity_1.AbstractEntity {
+    constructor(standardsSecurityDataInput) {
+        super(standardsSecurityDataInput);
+        _failed.set(this, void 0);
+        _name.set(this, void 0);
+        _passed.set(this, void 0);
+        _reference.set(this, void 0);
+        _score.set(this, void 0);
+        _total.set(this, void 0);
+        __classPrivateFieldSet(this, _failed, standardsSecurityDataInput[SecurityStandardsFields.COLUMN_FAILED]);
+        __classPrivateFieldSet(this, _name, standardsSecurityDataInput[SecurityStandardsFields.COLUMN_NAME]);
+        __classPrivateFieldSet(this, _passed, standardsSecurityDataInput[SecurityStandardsFields.COLUMN_PASSED]);
+        __classPrivateFieldSet(this, _reference, standardsSecurityDataInput[SecurityStandardsFields.COLUMN_REFERENCE]);
+        __classPrivateFieldSet(this, _score, standardsSecurityDataInput[SecurityStandardsFields.COLUMN_SCORE]);
+        __classPrivateFieldSet(this, _total, standardsSecurityDataInput[SecurityStandardsFields.COLUMN_TOTAL]);
+    }
+    get failed() {
+        return __classPrivateFieldGet(this, _failed);
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _name);
+    }
+    get passed() {
+        return __classPrivateFieldGet(this, _passed);
+    }
+    get reference() {
+        return __classPrivateFieldGet(this, _reference);
+    }
+    get score() {
+        return __classPrivateFieldGet(this, _score);
+    }
+    get total() {
+        return __classPrivateFieldGet(this, _total);
+    }
+    toJSON() {
+        return {
+            [SecurityStandardsFields.COLUMN_FAILED]: this.failed,
+            [SecurityStandardsFields.COLUMN_NAME]: this.name,
+            [SecurityStandardsFields.COLUMN_PASSED]: this.passed,
+            [SecurityStandardsFields.COLUMN_REFERENCE]: this.reference,
+            [SecurityStandardsFields.COLUMN_SCORE]: this.score,
+            [SecurityStandardsFields.COLUMN_TOTAL]: this.total,
+        };
+    }
+}
+exports.SecurityStandards = SecurityStandards;
+_failed = new WeakMap(), _name = new WeakMap(), _passed = new WeakMap(), _reference = new WeakMap(), _score = new WeakMap(), _total = new WeakMap();
+//# sourceMappingURL=securityStandards.js.map

package/build/standards/entities/standards/standards.d.ts

@@ -0,0 +1,17 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { SecurityStandards, SecurityStandardsType } from './securityStandards';
+export declare enum StandardsFields {
+    COLUMN_STANDARDS = "standards",
+    COLUMN_UPDATED_AT = "updatedAt"
+}
+export declare type StandardsType = {
+    [StandardsFields.COLUMN_STANDARDS]: Array<SecurityStandardsType>;
+    [StandardsFields.COLUMN_UPDATED_AT]: string;
+};
+export declare class Standards extends AbstractEntity<StandardsType> {
+    #private;
+    constructor(standardsDataInput: StandardsType);
+    get standards(): Array<SecurityStandards>;
+    get updatedAt(): string;
+    toJSON(): StandardsType;
+}

package/build/standards/entities/standards/standards.js

@@ -0,0 +1,48 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _standards, _updatedAt;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Standards = exports.StandardsFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const securityStandards_1 = require("./securityStandards");
+var StandardsFields;
+(function (StandardsFields) {
+    StandardsFields["COLUMN_STANDARDS"] = "standards";
+    StandardsFields["COLUMN_UPDATED_AT"] = "updatedAt";
+})(StandardsFields = exports.StandardsFields || (exports.StandardsFields = {}));
+class Standards extends abstractEntity_1.AbstractEntity {
+    constructor(standardsDataInput) {
+        super(standardsDataInput);
+        _standards.set(this, void 0);
+        _updatedAt.set(this, void 0);
+        __classPrivateFieldSet(this, _standards, standardsDataInput[StandardsFields.COLUMN_STANDARDS].map((securityStandards) => new securityStandards_1.SecurityStandards(securityStandards)));
+        __classPrivateFieldSet(this, _updatedAt, standardsDataInput[StandardsFields.COLUMN_UPDATED_AT]);
+    }
+    get standards() {
+        return __classPrivateFieldGet(this, _standards);
+    }
+    get updatedAt() {
+        return __classPrivateFieldGet(this, _updatedAt);
+    }
+    toJSON() {
+        return {
+            [StandardsFields.COLUMN_STANDARDS]: this.standards.map((securityStandards) => securityStandards.toJSON()),
+            [StandardsFields.COLUMN_UPDATED_AT]: this.updatedAt,
+        };
+    }
+}
+exports.Standards = Standards;
+_standards = new WeakMap(), _updatedAt = new WeakMap();
+//# sourceMappingURL=standards.js.map

package/build/standards/index.d.ts

@@ -0,0 +1,6 @@
+export * from './entities/standards/securityStandards';
+export * from './entities/standards/standards';
+export * from './entities/checks/securityChecks';
+export * from './entities/checks/checks';
+export * from './entities/resources/securityResources';
+export * from './entities/resources/resources';

package/build/standards/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./entities/standards/securityStandards"), exports);
+__exportStar(require("./entities/standards/standards"), exports);
+__exportStar(require("./entities/checks/securityChecks"), exports);
+__exportStar(require("./entities/checks/checks"), exports);
+__exportStar(require("./entities/resources/securityResources"), exports);
+__exportStar(require("./entities/resources/resources"), exports);
+//# sourceMappingURL=index.js.map

package/build/standards/standardsClient.d.ts

@@ -0,0 +1,14 @@
+import { AbstractClient, Parameters } from '../abstractClient';
+import { Standards } from './entities/standards/standards';
+import { GetResult } from '../getResult';
+import { Checks } from './entities/checks/checks';
+import { Resources } from './entities/resources/resources';
+export declare class StandardsClient extends AbstractClient {
+    /**
+     * The base path of the API
+     */
+    protected basePath: string;
+    listSecurityStandards(subscriptionReference: string, parameters?: Parameters): Promise<GetResult<Standards>>;
+    listSecurityChecks(subscriptionReference: string, standardReference: string, parameters?: Parameters): Promise<GetResult<Checks>>;
+    listSecurityResources(subscriptionReference: string, standardReference: string, checkReference: string, parameters?: Parameters): Promise<GetResult<Resources>>;
+}

package/build/standards/standardsClient.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardsClient = void 0;
+const abstractClient_1 = require("../abstractClient");
+const standards_1 = require("./entities/standards/standards");
+const getResult_1 = require("../getResult");
+const checks_1 = require("./entities/checks/checks");
+const resources_1 = require("./entities/resources/resources");
+class StandardsClient extends abstractClient_1.AbstractClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the API
+         */
+        this.basePath = '/security';
+    }
+    async listSecurityStandards(subscriptionReference, parameters = {}) {
+        this.path = `/${subscriptionReference}/standards`;
+        return new getResult_1.GetResult(standards_1.Standards, await this.get(parameters));
+    }
+    async listSecurityChecks(subscriptionReference, standardReference, parameters = {}) {
+        this.path = `/${subscriptionReference}/standards/${standardReference}/checks`;
+        return new getResult_1.GetResult(checks_1.Checks, await this.get(parameters));
+    }
+    async listSecurityResources(subscriptionReference, standardReference, checkReference, parameters = {}) {
+        this.path = `/${subscriptionReference}/standards/${standardReference}/checks/${checkReference}/resources`;
+        return new getResult_1.GetResult(resources_1.Resources, await this.get(parameters));
+    }
+}
+exports.StandardsClient = StandardsClient;
+//# sourceMappingURL=standardsClient.js.map

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/ArrowSphere/nodejs-api-client.git"
   },
-  "version": "3.16.0-rc.1",
+  "version": "3.17.0-rc.1",
   "description": "Node.js client for ArrowSphere's public API",
   "main": "build/index.js",
   "types": "build/index.d.ts",