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

package/build/abstractClient.js

@@ -63,6 +63,14 @@ class AbstractClient {
         this.client = client !== null && client !== void 0 ? client : axios_1.default.create();
         // Prevent axios from throwing its own errors, let us do that
         this.client.defaults.validateStatus = null;
+        this.client.interceptors.request.use((request) => {
+            console.log('AXIOS - Starting Request : ', JSON.stringify(request, null, 2));
+            return request;
+        });
+        this.client.interceptors.response.use((response) => {
+            console.log('AXIOS - Response : ', JSON.stringify(response, null, 2));
+            return response;
+        });
     }
     /**
      * Sets the Client ArrowSphere API key
@@ -124,9 +132,13 @@ class AbstractClient {
      * @returns Promise\<AxiosResponse['data']\>
      */
     async get(parameters = {}, headers = {}, options = {}) {
+        console.log('GET parameters', parameters);
+        console.log('GET options', options);
+        console.log('GET Header', headers);
         const response = await this.client.get(this.generateUrl(parameters, options), {
             headers: this.prepareHeaders(headers),
         });
+        console.log('GET Response', response);
         return this.getResponse(response);
     }
     /**
@@ -165,9 +177,14 @@ class AbstractClient {
      * @param options - Options to send
      */
     async post(payload = {}, parameters = {}, headers = {}, options = {}) {
+        console.log('POST parameters', parameters);
+        console.log('POST options', options);
+        console.log('POST payload', payload);
+        console.log('POST Header', headers);
         const response = await this.client.post(this.generateUrl(parameters, options), payload, {
             headers: this.prepareHeaders(headers),
         });
+        console.log('POST Response', response);
         return this.getResponse(response);
     }
     /**
@@ -179,9 +196,14 @@ class AbstractClient {
      * @returns Promise\<void\>
      */
     async put(payload = {}, parameters = {}, headers = {}, options = {}) {
+        console.log('PUT parameters', parameters);
+        console.log('PUT options', options);
+        console.log('PUT payload', payload);
+        console.log('PUT Header', headers);
         const response = await this.client.put(this.generateUrl(parameters, options), payload, {
             headers: this.prepareHeaders(headers),
         });
+        console.log('PUT Response', response);
         return this.getResponse(response);
     }
     /**
@@ -193,9 +215,14 @@ class AbstractClient {
      * @returns Promise\<T\>
      */
     async patch(payload = {}, parameters = {}, headers = {}, options = {}) {
+        console.log('PATCH parameters', parameters);
+        console.log('PATCH options', options);
+        console.log('PATCH payload', payload);
+        console.log('PATCH Header', headers);
         const response = await this.client.patch(this.generateUrl(parameters, options), payload, {
             headers: this.prepareHeaders(headers),
         });
+        console.log('PATCH Response', response);
         return this.getResponse(response);
     }
     /**

package/build/index.d.ts

@@ -8,11 +8,13 @@ export * from './customers/';
 export * from './exception/';
 export * from './general/';
 export * from './getResult';
+export * from './pagination';
 export * from './licenses/';
 export * from './orders/';
 export * from './publicApiClient';
 export * from './publicGraphQLClient';
 export * from './shared/';
+export * from './security/';
 export * from './subscriptions/';
 export { ContactInformation };
 import * as ContactInformation from './contact';

package/build/index.js

@@ -33,11 +33,13 @@ __exportStar(require("./customers/"), exports);
 __exportStar(require("./exception/"), exports);
 __exportStar(require("./general/"), exports);
 __exportStar(require("./getResult"), exports);
+__exportStar(require("./pagination"), exports);
 __exportStar(require("./licenses/"), exports);
 __exportStar(require("./orders/"), exports);
 __exportStar(require("./publicApiClient"), exports);
 __exportStar(require("./publicGraphQLClient"), exports);
 __exportStar(require("./shared/"), exports);
+__exportStar(require("./security/"), exports);
 __exportStar(require("./subscriptions/"), exports);
 const ContactInformation = __importStar(require("./contact"));
 exports.ContactInformation = ContactInformation;

package/build/publicApiClient.d.ts

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

package/build/publicApiClient.js

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

package/build/security/index.d.ts

@@ -0,0 +1,2 @@
+export * from './register';
+export * from './standards';

package/build/security/index.js

@@ -0,0 +1,15 @@
+"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("./register"), exports);
+__exportStar(require("./standards"), exports);
+//# sourceMappingURL=index.js.map

package/build/security/register/entity/registrationLink.d.ts

@@ -0,0 +1,13 @@
+import { AbstractEntity } from '../../../abstractEntity';
+export declare enum RegistrationLinkFields {
+    COLUMN_REGISTRATION_LINK = "registrationLink"
+}
+export declare type RegistrationLinkType = {
+    [RegistrationLinkFields.COLUMN_REGISTRATION_LINK]: string;
+};
+export declare class RegistrationLink extends AbstractEntity<RegistrationLinkType> {
+    #private;
+    constructor(registrationLinkInput: RegistrationLinkType);
+    get registrationLink(): string;
+    toJSON(): RegistrationLinkType;
+}

package/build/security/register/entity/registrationLink.js

@@ -0,0 +1,40 @@
+"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 _registrationLink;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistrationLink = exports.RegistrationLinkFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var RegistrationLinkFields;
+(function (RegistrationLinkFields) {
+    RegistrationLinkFields["COLUMN_REGISTRATION_LINK"] = "registrationLink";
+})(RegistrationLinkFields = exports.RegistrationLinkFields || (exports.RegistrationLinkFields = {}));
+class RegistrationLink extends abstractEntity_1.AbstractEntity {
+    constructor(registrationLinkInput) {
+        super(registrationLinkInput);
+        _registrationLink.set(this, void 0);
+        __classPrivateFieldSet(this, _registrationLink, registrationLinkInput[RegistrationLinkFields.COLUMN_REGISTRATION_LINK]);
+    }
+    get registrationLink() {
+        return __classPrivateFieldGet(this, _registrationLink);
+    }
+    toJSON() {
+        return {
+            [RegistrationLinkFields.COLUMN_REGISTRATION_LINK]: this.registrationLink,
+        };
+    }
+}
+exports.RegistrationLink = RegistrationLink;
+_registrationLink = new WeakMap();
+//# sourceMappingURL=registrationLink.js.map

package/build/security/register/index.d.ts

@@ -0,0 +1,2 @@
+export * from './entity/registrationLink';
+export * from './registerClient';

package/build/security/register/index.js

@@ -0,0 +1,15 @@
+"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("./entity/registrationLink"), exports);
+__exportStar(require("./registerClient"), exports);
+//# sourceMappingURL=index.js.map

package/build/security/register/registerClient.d.ts

@@ -0,0 +1,13 @@
+import { AbstractClient, Parameters } from '../../abstractClient';
+import { GetResult } from '../../getResult';
+import { RegistrationLink } from './entity/registrationLink';
+export declare class RegisterClient extends AbstractClient {
+    /**
+     * The base path of the API
+     */
+    protected basePath: string;
+    register(subscriptionReference: string, parameters?: Parameters): Promise<GetResult<RegistrationLink>>;
+    deregister(subscriptionReference: string, parameters?: Parameters): Promise<void>;
+    checkRegister(subscriptionReference: string, parameters?: Parameters): Promise<void>;
+    triggerAsynchronousUpdate(subscriptionReference: string, parameters?: Parameters): Promise<void>;
+}

package/build/security/register/registerClient.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisterClient = void 0;
+const abstractClient_1 = require("../../abstractClient");
+const getResult_1 = require("../../getResult");
+const registrationLink_1 = require("./entity/registrationLink");
+class RegisterClient extends abstractClient_1.AbstractClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the API
+         */
+        this.basePath = '/security';
+    }
+    async register(subscriptionReference, parameters = {}) {
+        this.path = `/${subscriptionReference}/register`;
+        return new getResult_1.GetResult(registrationLink_1.RegistrationLink, await this.post(parameters));
+    }
+    async deregister(subscriptionReference, parameters = {}) {
+        this.path = `/${subscriptionReference}/deregister`;
+        return await this.post(parameters);
+    }
+    async checkRegister(subscriptionReference, parameters = {}) {
+        this.path = `/${subscriptionReference}/register/check`;
+        return await this.get(parameters);
+    }
+    async triggerAsynchronousUpdate(subscriptionReference, parameters = {}) {
+        this.path = `/${subscriptionReference}/update`;
+        return await this.post(parameters);
+    }
+}
+exports.RegisterClient = RegisterClient;
+//# sourceMappingURL=registerClient.js.map

package/build/security/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/security/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/security/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/security/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/security/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/security/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/security/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/security/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/security/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/security/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/security/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/security/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/security/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/security/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/security/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/security/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",
+  "version": "3.17.0-rc.2",
   "description": "Node.js client for ArrowSphere's public API",
   "main": "build/index.js",
   "types": "build/index.d.ts",