@arrowsphere/api-client 3.55.0 → 3.56.0

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.56.0] - 2023-10-05
+- The **security** endpoint is now considered deprecrated.
+- Add the **register** and **standards** functions that used the **security** endpoint in the wellArchitected one.
+
+
 ## [3.55.0] - 2023-09-25
 
 ### Changed

package/build/index.d.ts

@@ -23,5 +23,7 @@ export * from './subscriptions/';
 export * from './supportCenter/';
 export * from './securityScore/';
 export * from './user/';
+export { WellArchitected };
+import * as WellArchitected from './wellArchitected';
 export { ContactInformation };
 import * as ContactInformation from './contact';

package/build/index.js

@@ -26,7 +26,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContactInformation = void 0;
+exports.ContactInformation = exports.WellArchitected = void 0;
 __exportStar(require("./axiosSingleton"), exports);
 __exportStar(require("./abstractRestfulClient"), exports);
 __exportStar(require("./abstractEntity"), exports);
@@ -52,6 +52,8 @@ __exportStar(require("./subscriptions/"), exports);
 __exportStar(require("./supportCenter/"), exports);
 __exportStar(require("./securityScore/"), exports);
 __exportStar(require("./user/"), exports);
+const WellArchitected = __importStar(require("./wellArchitected"));
+exports.WellArchitected = WellArchitected;
 const ContactInformation = __importStar(require("./contact"));
 exports.ContactInformation = ContactInformation;
 //# sourceMappingURL=index.js.map

package/build/publicApiClient.d.ts

@@ -7,13 +7,13 @@ 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';
+import { WellArchitectedRegisterClient, WellArchitectedStandardsClient } from './wellArchitected';
 import { CartClient } from './cart/cartClient';
 import { SupportCenterClient } from './supportCenter';
 import { CatalogClient } from './catalog';
 import { UserClient } from './user';
 import { NotificationsClient } from './notifications';
+import { RegisterClient, StandardsClient } from './security';
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -61,8 +61,18 @@ export declare class PublicApiClient extends AbstractRestfulClient {
      */
     getCampaignClient(configuration?: ConfigurationsClient): CampaignClient;
     getConsumptionClient(configuration?: ConfigurationsClient): ConsumptionClient;
+    /**
+     * @deprecated
+     * Prefer using getWellArchitectedStandardsClient
+     */
     getSecurityStandardsClient(configuration?: ConfigurationsClient): StandardsClient;
+    /**
+     * @deprecated
+     * Prefer using getWellArchitectedRegisterClient
+     */
     getSecurityRegisterClient(configuration?: ConfigurationsClient): RegisterClient;
+    getWellArchitectedStandardsClient(configuration?: ConfigurationsClient): WellArchitectedStandardsClient;
+    getWellArchitectedRegisterClient(configuration?: ConfigurationsClient): WellArchitectedRegisterClient;
     getCartClient(configuration?: ConfigurationsClient): CartClient;
     getSupportCenterClient(configuration?: ConfigurationsClient): SupportCenterClient;
     getCatalogClient(configuration?: ConfigurationsClient): CatalogClient;

package/build/publicApiClient.js

@@ -10,13 +10,13 @@ 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");
+const wellArchitected_1 = require("./wellArchitected");
 const cartClient_1 = require("./cart/cartClient");
 const supportCenter_1 = require("./supportCenter");
 const catalog_1 = require("./catalog");
 const user_1 = require("./user");
 const notifications_1 = require("./notifications");
+const security_1 = require("./security");
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -109,16 +109,34 @@ class PublicApiClient extends abstractRestfulClient_1.AbstractRestfulClient {
         this.applyConfig(client);
         return client;
     }
+    /**
+     * @deprecated
+     * Prefer using getWellArchitectedStandardsClient
+     */
     getSecurityStandardsClient(configuration) {
-        const client = new standardsClient_1.StandardsClient(configuration);
+        const client = new security_1.StandardsClient(configuration);
         this.applyConfig(client);
         return client;
     }
+    /**
+     * @deprecated
+     * Prefer using getWellArchitectedRegisterClient
+     */
     getSecurityRegisterClient(configuration) {
         const client = new security_1.RegisterClient(configuration);
         this.applyConfig(client);
         return client;
     }
+    getWellArchitectedStandardsClient(configuration) {
+        const client = new wellArchitected_1.WellArchitectedStandardsClient(configuration);
+        this.applyConfig(client);
+        return client;
+    }
+    getWellArchitectedRegisterClient(configuration) {
+        const client = new wellArchitected_1.WellArchitectedRegisterClient(configuration);
+        this.applyConfig(client);
+        return client;
+    }
     getCartClient(configuration) {
         const client = new cartClient_1.CartClient(configuration);
         this.applyConfig(client);

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

@@ -6,8 +6,24 @@ export declare class RegisterClient extends AbstractRestfulClient {
      * The base path of the API
      */
     protected basePath: string;
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     register(subscriptionReference: string, parameters?: Parameters): Promise<GetResult<RegistrationLink>>;
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     deregister(subscriptionReference: string, parameters?: Parameters): Promise<void>;
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     checkRegister(subscriptionReference: string, parameters?: Parameters): Promise<void>;
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     triggerAsynchronousUpdate(subscriptionReference: string, parameters?: Parameters): Promise<void>;
 }

package/build/security/register/registerClient.js

@@ -12,18 +12,34 @@ class RegisterClient extends abstractRestfulClient_1.AbstractRestfulClient {
          */
         this.basePath = '/security';
     }
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     async register(subscriptionReference, parameters = {}) {
         this.path = `/${subscriptionReference}/register`;
         return new getResult_1.GetResult(registrationLink_1.RegistrationLink, await this.post(parameters));
     }
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     async deregister(subscriptionReference, parameters = {}) {
         this.path = `/${subscriptionReference}/deregister`;
         return await this.post(parameters);
     }
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     async checkRegister(subscriptionReference, parameters = {}) {
         this.path = `/${subscriptionReference}/register/check`;
         return await this.get(parameters);
     }
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     async triggerAsynchronousUpdate(subscriptionReference, parameters = {}) {
         this.path = `/${subscriptionReference}/update`;
         return await this.post(parameters);

package/build/security/standards/standardsClient.d.ts

@@ -13,17 +13,29 @@ export declare class StandardsClient extends AbstractRestfulClient {
      * Prefer using listSecurityStandardsWithAccountReference
      */
     listSecurityStandards(subscriptionReference: string, parameters?: Parameters): Promise<GetResult<Standards>>;
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     listSecurityStandardsWithAccountReference(subscriptionReference: string, parameters: Parameters | undefined, accountReference: string): Promise<GetResult<Standards>>;
     /**
      * @deprecated
      * Prefer using listSecurityChecksWithAccountReference
      */
     listSecurityChecks(subscriptionReference: string, standardReference: string, parameters?: Parameters): Promise<GetResult<Checks>>;
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     listSecurityChecksWithAccountReference(subscriptionReference: string, standardReference: string, accountReference: string, parameters?: Parameters): Promise<GetResult<Checks>>;
     /**
      * @deprecated
      * Prefer using listSecurityResourcesWithAccountReference
      */
     listSecurityResources(subscriptionReference: string, standardReference: string, checkReference: string, parameters?: Parameters): Promise<GetResult<Resources>>;
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     listSecurityResourcesWithAccountReference(subscriptionReference: string, standardReference: string, checkReference: string, accountReference: string, parameters?: Parameters): Promise<GetResult<Resources>>;
 }

package/build/security/standards/standardsClient.js

@@ -22,6 +22,10 @@ class StandardsClient extends abstractRestfulClient_1.AbstractRestfulClient {
         this.path = `/${subscriptionReference}/standards`;
         return new getResult_1.GetResult(standards_1.Standards, await this.get(parameters));
     }
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     async listSecurityStandardsWithAccountReference(subscriptionReference, parameters = {}, accountReference) {
         this.path = `/${subscriptionReference}/accounts/${accountReference}/standards`;
         return new getResult_1.GetResult(standards_1.Standards, await this.get(parameters));
@@ -34,6 +38,10 @@ class StandardsClient extends abstractRestfulClient_1.AbstractRestfulClient {
         this.path = `/${subscriptionReference}/standards/${standardReference}/checks`;
         return new getResult_1.GetResult(checks_1.Checks, await this.get(parameters));
     }
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     async listSecurityChecksWithAccountReference(subscriptionReference, standardReference, accountReference, parameters = {}) {
         this.path = `/${subscriptionReference}/accounts/${accountReference}/standards/${standardReference}/checks`;
         return new getResult_1.GetResult(checks_1.Checks, await this.get(parameters));
@@ -46,6 +54,10 @@ class StandardsClient extends abstractRestfulClient_1.AbstractRestfulClient {
         this.path = `/${subscriptionReference}/standards/${standardReference}/checks/${checkReference}/resources`;
         return new getResult_1.GetResult(resources_1.Resources, await this.get(parameters));
     }
+    /**
+     * @deprecated
+     * Prefer using the wellArchitected version
+     */
     async listSecurityResourcesWithAccountReference(subscriptionReference, standardReference, checkReference, accountReference, parameters = {}) {
         this.path = `/${subscriptionReference}/accounts/${accountReference}/standards/${standardReference}/checks/${checkReference}/resources`;
         return new getResult_1.GetResult(resources_1.Resources, await this.get(parameters));

package/build/wellArchitected/index.d.ts

@@ -6,3 +6,5 @@ export * from './entities/getAdminData';
 export * from './entities/getPartnerData';
 export * from './entities/getCustomerData';
 export * from './entities/getCustomerAccountData';
+export * from './register';
+export * from './standards';

package/build/wellArchitected/index.js

@@ -22,4 +22,6 @@ __exportStar(require("./entities/getAdminData"), exports);
 __exportStar(require("./entities/getPartnerData"), exports);
 __exportStar(require("./entities/getCustomerData"), exports);
 __exportStar(require("./entities/getCustomerAccountData"), exports);
+__exportStar(require("./register"), exports);
+__exportStar(require("./standards"), exports);
 //# sourceMappingURL=index.js.map

package/build/wellArchitected/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/wellArchitected/register/entity/registrationLink.js

@@ -0,0 +1,38 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RegistrationLink_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_registrationLink.set(this, void 0);
+        __classPrivateFieldSet(this, _RegistrationLink_registrationLink, registrationLinkInput[RegistrationLinkFields.COLUMN_REGISTRATION_LINK], "f");
+    }
+    get registrationLink() {
+        return __classPrivateFieldGet(this, _RegistrationLink_registrationLink, "f");
+    }
+    toJSON() {
+        return {
+            [RegistrationLinkFields.COLUMN_REGISTRATION_LINK]: this.registrationLink,
+        };
+    }
+}
+exports.RegistrationLink = RegistrationLink;
+_RegistrationLink_registrationLink = new WeakMap();
+//# sourceMappingURL=registrationLink.js.map

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

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

package/build/wellArchitected/register/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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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/wellArchitected/register/registerClient.d.ts

@@ -0,0 +1,13 @@
+import { AbstractRestfulClient, Parameters } from '../../abstractRestfulClient';
+import { GetResult } from '../../getResult';
+import { RegistrationLink } from './entity/registrationLink';
+export declare class WellArchitectedRegisterClient extends AbstractRestfulClient {
+    /**
+     * 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/wellArchitected/register/registerClient.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WellArchitectedRegisterClient = void 0;
+const abstractRestfulClient_1 = require("../../abstractRestfulClient");
+const getResult_1 = require("../../getResult");
+const registrationLink_1 = require("./entity/registrationLink");
+class WellArchitectedRegisterClient extends abstractRestfulClient_1.AbstractRestfulClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the API
+         */
+        this.basePath = '/wellArchitected';
+    }
+    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.WellArchitectedRegisterClient = WellArchitectedRegisterClient;
+//# sourceMappingURL=registerClient.js.map

package/build/wellArchitected/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/wellArchitected/standards/entities/checks/checks.js

@@ -0,0 +1,46 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Checks_checks, _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_checks.set(this, void 0);
+        _Checks_updatedAt.set(this, void 0);
+        __classPrivateFieldSet(this, _Checks_checks, checksDataInput[ChecksFields.COLUMN_CHECKS].map((securityChecks) => new securityChecks_1.SecurityChecks(securityChecks)), "f");
+        __classPrivateFieldSet(this, _Checks_updatedAt, checksDataInput[ChecksFields.COLUMN_UPDATED_AT], "f");
+    }
+    get checks() {
+        return __classPrivateFieldGet(this, _Checks_checks, "f");
+    }
+    get updatedAt() {
+        return __classPrivateFieldGet(this, _Checks_updatedAt, "f");
+    }
+    toJSON() {
+        return {
+            [ChecksFields.COLUMN_CHECKS]: this.checks.map((securityChecks) => securityChecks.toJSON()),
+            [ChecksFields.COLUMN_UPDATED_AT]: this.updatedAt,
+        };
+    }
+}
+exports.Checks = Checks;
+_Checks_checks = new WeakMap(), _Checks_updatedAt = new WeakMap();
+//# sourceMappingURL=checks.js.map

package/build/wellArchitected/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/wellArchitected/standards/entities/checks/securityChecks.js

@@ -0,0 +1,94 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SecurityChecks_description, _SecurityChecks_flagged, _SecurityChecks_isFailed, _SecurityChecks_metadata, _SecurityChecks_name, _SecurityChecks_processed, _SecurityChecks_reference, _SecurityChecks_score, _SecurityChecks_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);
+        _SecurityChecks_description.set(this, void 0);
+        _SecurityChecks_flagged.set(this, void 0);
+        _SecurityChecks_isFailed.set(this, void 0);
+        _SecurityChecks_metadata.set(this, void 0);
+        _SecurityChecks_name.set(this, void 0);
+        _SecurityChecks_processed.set(this, void 0);
+        _SecurityChecks_reference.set(this, void 0);
+        _SecurityChecks_score.set(this, void 0);
+        _SecurityChecks_severity.set(this, void 0);
+        __classPrivateFieldSet(this, _SecurityChecks_description, securityChecksDataInput[SecurityChecksFields.COLUMN_DESCRIPTION], "f");
+        __classPrivateFieldSet(this, _SecurityChecks_flagged, securityChecksDataInput[SecurityChecksFields.COLUMN_FLAGGED], "f");
+        __classPrivateFieldSet(this, _SecurityChecks_isFailed, securityChecksDataInput[SecurityChecksFields.COLUMN_IS_FAILED], "f");
+        __classPrivateFieldSet(this, _SecurityChecks_metadata, securityChecksDataInput[SecurityChecksFields.COLUMN_METADATA], "f");
+        __classPrivateFieldSet(this, _SecurityChecks_name, securityChecksDataInput[SecurityChecksFields.COLUMN_NAME], "f");
+        __classPrivateFieldSet(this, _SecurityChecks_processed, securityChecksDataInput[SecurityChecksFields.COLUMN_PROCESSED], "f");
+        __classPrivateFieldSet(this, _SecurityChecks_reference, securityChecksDataInput[SecurityChecksFields.COLUMN_REFERENCE], "f");
+        __classPrivateFieldSet(this, _SecurityChecks_score, securityChecksDataInput[SecurityChecksFields.COLUMN_SCORE], "f");
+        __classPrivateFieldSet(this, _SecurityChecks_severity, securityChecksDataInput[SecurityChecksFields.COLUMN_SEVERITY], "f");
+    }
+    get description() {
+        return __classPrivateFieldGet(this, _SecurityChecks_description, "f");
+    }
+    get flagged() {
+        return __classPrivateFieldGet(this, _SecurityChecks_flagged, "f");
+    }
+    get isFailed() {
+        return __classPrivateFieldGet(this, _SecurityChecks_isFailed, "f");
+    }
+    get metadata() {
+        return __classPrivateFieldGet(this, _SecurityChecks_metadata, "f");
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _SecurityChecks_name, "f");
+    }
+    get processed() {
+        return __classPrivateFieldGet(this, _SecurityChecks_processed, "f");
+    }
+    get reference() {
+        return __classPrivateFieldGet(this, _SecurityChecks_reference, "f");
+    }
+    get score() {
+        return __classPrivateFieldGet(this, _SecurityChecks_score, "f");
+    }
+    get severity() {
+        return __classPrivateFieldGet(this, _SecurityChecks_severity, "f");
+    }
+    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;
+_SecurityChecks_description = new WeakMap(), _SecurityChecks_flagged = new WeakMap(), _SecurityChecks_isFailed = new WeakMap(), _SecurityChecks_metadata = new WeakMap(), _SecurityChecks_name = new WeakMap(), _SecurityChecks_processed = new WeakMap(), _SecurityChecks_reference = new WeakMap(), _SecurityChecks_score = new WeakMap(), _SecurityChecks_severity = new WeakMap();
+//# sourceMappingURL=securityChecks.js.map

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

@@ -0,0 +1,17 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+import { SecurityResources, SecurityResourcesType } from './securityResources';
+export declare enum ResourcesFields {
+    COLUMN_HEADERS = "headers",
+    COLUMN_RESOURCES = "resources"
+}
+export declare type ResourcesType = {
+    [ResourcesFields.COLUMN_HEADERS]: Array<string>;
+    [ResourcesFields.COLUMN_RESOURCES]: Array<SecurityResourcesType>;
+};
+export declare class Resources extends AbstractEntity<ResourcesType> {
+    #private;
+    constructor(resources: ResourcesType);
+    get resources(): Array<SecurityResources>;
+    get headers(): Array<string>;
+    toJSON(): ResourcesType;
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Resources_headers, _Resources_resources;
+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_HEADERS"] = "headers";
+    ResourcesFields["COLUMN_RESOURCES"] = "resources";
+})(ResourcesFields = exports.ResourcesFields || (exports.ResourcesFields = {}));
+class Resources extends abstractEntity_1.AbstractEntity {
+    constructor(resources) {
+        super(resources);
+        _Resources_headers.set(this, void 0);
+        _Resources_resources.set(this, void 0);
+        __classPrivateFieldSet(this, _Resources_headers, resources[ResourcesFields.COLUMN_HEADERS], "f");
+        __classPrivateFieldSet(this, _Resources_resources, resources[ResourcesFields.COLUMN_RESOURCES].map((securityResources) => new securityResources_1.SecurityResources(securityResources)), "f");
+    }
+    get resources() {
+        return __classPrivateFieldGet(this, _Resources_resources, "f");
+    }
+    get headers() {
+        return __classPrivateFieldGet(this, _Resources_headers, "f");
+    }
+    toJSON() {
+        return {
+            [ResourcesFields.COLUMN_HEADERS]: this.headers,
+            [ResourcesFields.COLUMN_RESOURCES]: this.resources.map((securityResources) => securityResources.toJSON()),
+        };
+    }
+}
+exports.Resources = Resources;
+_Resources_headers = new WeakMap(), _Resources_resources = new WeakMap();
+//# sourceMappingURL=resources.js.map

package/build/wellArchitected/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/wellArchitected/standards/entities/resources/securityResources.js

@@ -0,0 +1,45 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SecurityResources_status, _SecurityResources_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);
+        _SecurityResources_status.set(this, void 0);
+        _SecurityResources_values.set(this, void 0);
+        __classPrivateFieldSet(this, _SecurityResources_status, securityResources[SecurityResourcesFields.COLUMN_STATUS], "f");
+        __classPrivateFieldSet(this, _SecurityResources_values, securityResources[SecurityResourcesFields.COLUMN_VALUES], "f");
+    }
+    get status() {
+        return __classPrivateFieldGet(this, _SecurityResources_status, "f");
+    }
+    get values() {
+        return __classPrivateFieldGet(this, _SecurityResources_values, "f");
+    }
+    toJSON() {
+        return {
+            [SecurityResourcesFields.COLUMN_STATUS]: this.status,
+            [SecurityResourcesFields.COLUMN_VALUES]: this.values,
+        };
+    }
+}
+exports.SecurityResources = SecurityResources;
+_SecurityResources_status = new WeakMap(), _SecurityResources_values = new WeakMap();
+//# sourceMappingURL=securityResources.js.map

package/build/wellArchitected/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/wellArchitected/standards/entities/standards/securityStandards.js

@@ -0,0 +1,73 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SecurityStandards_failed, _SecurityStandards_name, _SecurityStandards_passed, _SecurityStandards_reference, _SecurityStandards_score, _SecurityStandards_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);
+        _SecurityStandards_failed.set(this, void 0);
+        _SecurityStandards_name.set(this, void 0);
+        _SecurityStandards_passed.set(this, void 0);
+        _SecurityStandards_reference.set(this, void 0);
+        _SecurityStandards_score.set(this, void 0);
+        _SecurityStandards_total.set(this, void 0);
+        __classPrivateFieldSet(this, _SecurityStandards_failed, standardsSecurityDataInput[SecurityStandardsFields.COLUMN_FAILED], "f");
+        __classPrivateFieldSet(this, _SecurityStandards_name, standardsSecurityDataInput[SecurityStandardsFields.COLUMN_NAME], "f");
+        __classPrivateFieldSet(this, _SecurityStandards_passed, standardsSecurityDataInput[SecurityStandardsFields.COLUMN_PASSED], "f");
+        __classPrivateFieldSet(this, _SecurityStandards_reference, standardsSecurityDataInput[SecurityStandardsFields.COLUMN_REFERENCE], "f");
+        __classPrivateFieldSet(this, _SecurityStandards_score, standardsSecurityDataInput[SecurityStandardsFields.COLUMN_SCORE], "f");
+        __classPrivateFieldSet(this, _SecurityStandards_total, standardsSecurityDataInput[SecurityStandardsFields.COLUMN_TOTAL], "f");
+    }
+    get failed() {
+        return __classPrivateFieldGet(this, _SecurityStandards_failed, "f");
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _SecurityStandards_name, "f");
+    }
+    get passed() {
+        return __classPrivateFieldGet(this, _SecurityStandards_passed, "f");
+    }
+    get reference() {
+        return __classPrivateFieldGet(this, _SecurityStandards_reference, "f");
+    }
+    get score() {
+        return __classPrivateFieldGet(this, _SecurityStandards_score, "f");
+    }
+    get total() {
+        return __classPrivateFieldGet(this, _SecurityStandards_total, "f");
+    }
+    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;
+_SecurityStandards_failed = new WeakMap(), _SecurityStandards_name = new WeakMap(), _SecurityStandards_passed = new WeakMap(), _SecurityStandards_reference = new WeakMap(), _SecurityStandards_score = new WeakMap(), _SecurityStandards_total = new WeakMap();
+//# sourceMappingURL=securityStandards.js.map

package/build/wellArchitected/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/wellArchitected/standards/entities/standards/standards.js

@@ -0,0 +1,46 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Standards_standards, _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_standards.set(this, void 0);
+        _Standards_updatedAt.set(this, void 0);
+        __classPrivateFieldSet(this, _Standards_standards, standardsDataInput[StandardsFields.COLUMN_STANDARDS].map((securityStandards) => new securityStandards_1.SecurityStandards(securityStandards)), "f");
+        __classPrivateFieldSet(this, _Standards_updatedAt, standardsDataInput[StandardsFields.COLUMN_UPDATED_AT], "f");
+    }
+    get standards() {
+        return __classPrivateFieldGet(this, _Standards_standards, "f");
+    }
+    get updatedAt() {
+        return __classPrivateFieldGet(this, _Standards_updatedAt, "f");
+    }
+    toJSON() {
+        return {
+            [StandardsFields.COLUMN_STANDARDS]: this.standards.map((securityStandards) => securityStandards.toJSON()),
+            [StandardsFields.COLUMN_UPDATED_AT]: this.updatedAt,
+        };
+    }
+}
+exports.Standards = Standards;
+_Standards_standards = new WeakMap(), _Standards_updatedAt = new WeakMap();
+//# sourceMappingURL=standards.js.map

package/build/wellArchitected/standards/index.d.ts

@@ -0,0 +1,7 @@
+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';
+export * from './standardsClient';

package/build/wellArchitected/standards/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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);
+__exportStar(require("./standardsClient"), exports);
+//# sourceMappingURL=index.js.map

package/build/wellArchitected/standards/standardsClient.d.ts

@@ -0,0 +1,14 @@
+import { AbstractRestfulClient, Parameters } from '../../abstractRestfulClient';
+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 WellArchitectedStandardsClient extends AbstractRestfulClient {
+    /**
+     * The base path of the API
+     */
+    protected basePath: string;
+    listSecurityStandardsWithAccountReference(subscriptionReference: string, parameters: Parameters | undefined, accountReference: string): Promise<GetResult<Standards>>;
+    listSecurityChecksWithAccountReference(subscriptionReference: string, standardReference: string, accountReference: string, parameters?: Parameters): Promise<GetResult<Checks>>;
+    listSecurityResourcesWithAccountReference(subscriptionReference: string, standardReference: string, checkReference: string, accountReference: string, parameters?: Parameters): Promise<GetResult<Resources>>;
+}

package/build/wellArchitected/standards/standardsClient.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WellArchitectedStandardsClient = void 0;
+const abstractRestfulClient_1 = require("../../abstractRestfulClient");
+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 WellArchitectedStandardsClient extends abstractRestfulClient_1.AbstractRestfulClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the API
+         */
+        this.basePath = '/wellArchitected';
+    }
+    async listSecurityStandardsWithAccountReference(subscriptionReference, parameters = {}, accountReference) {
+        this.path = `/${subscriptionReference}/accounts/${accountReference}/standards`;
+        return new getResult_1.GetResult(standards_1.Standards, await this.get(parameters));
+    }
+    async listSecurityChecksWithAccountReference(subscriptionReference, standardReference, accountReference, parameters = {}) {
+        this.path = `/${subscriptionReference}/accounts/${accountReference}/standards/${standardReference}/checks`;
+        return new getResult_1.GetResult(checks_1.Checks, await this.get(parameters));
+    }
+    async listSecurityResourcesWithAccountReference(subscriptionReference, standardReference, checkReference, accountReference, parameters = {}) {
+        this.path = `/${subscriptionReference}/accounts/${accountReference}/standards/${standardReference}/checks/${checkReference}/resources`;
+        return new getResult_1.GetResult(resources_1.Resources, await this.get(parameters));
+    }
+}
+exports.WellArchitectedStandardsClient = WellArchitectedStandardsClient;
+//# sourceMappingURL=standardsClient.js.map

package/package.json

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