@arrowsphere/api-client 3.55.0-rc.fdi.7 → 3.56.0

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

package/build/account/accountGraphQLClient.d.ts

@@ -1,10 +0,0 @@
-import { AbstractGraphQLClient } from '../abstractGraphQLClient';
-import { GetAccountQuery } from './types/accountGraphQLQueries';
-import { GetAccountType } from './types/accountGraphQLTypes';
-export declare class AccountGraphQLClient extends AbstractGraphQLClient {
-    /**
-     * The base path of the API
-     */
-    protected basePath: string;
-    findByQuery(query: GetAccountQuery): Promise<GetAccountType | null>;
-}

package/build/account/accountGraphQLClient.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AccountGraphQLClient = void 0;
-const abstractGraphQLClient_1 = require("../abstractGraphQLClient");
-class AccountGraphQLClient extends abstractGraphQLClient_1.AbstractGraphQLClient {
-    constructor() {
-        super(...arguments);
-        /**
-         * The base path of the API
-         */
-        this.basePath = '/v2';
-    }
-    async findByQuery(query) {
-        this.path = '/graphql';
-        console.info('GRAPHQL Query brut :', query);
-        const queryStr = this.stringifyQuery(query);
-        console.info('GRAPHQL Query after stringify :', queryStr);
-        try {
-            return await this.post(queryStr);
-        }
-        catch (error) {
-            return null;
-        }
-    }
-}
-exports.AccountGraphQLClient = AccountGraphQLClient;
-//# sourceMappingURL=accountGraphQLClient.js.map

package/build/account/index.d.ts

@@ -1,3 +0,0 @@
-export * from './types/accountGraphQLQueries';
-export * from './types/accountGraphQLTypes';
-export * from './accountGraphQLClient';

package/build/account/types/accountGraphQLQueries.d.ts

@@ -1,43 +0,0 @@
-import { Merge, Schema } from 'type-fest';
-import { AccountAttributeType } from './accountGraphQLTypes';
-import { AccountAttributeSchema } from './accountGraphQLSchemas';
-export declare type GetAccountQuery = {
-    getUsers?: GetAccountQueryRequest;
-};
-export declare type GetAccountQueryRequest = Merge<{
-    __args: QueryAccountArgument;
-}, AccountAttributeSchema>;
-export declare type QueryAccountArgument = {
-    paginate?: PaginateAccountArgument;
-    searchBody?: SearchBodyAccountArgument;
-};
-export declare type PaginateAccountArgument = {
-    page: number;
-    perPage: number;
-};
-export declare type SearchBodyAccountArgument = {
-    keywords?: string;
-    keywordsByField?: KeywordsByFieldsAccountArgument[];
-    filters?: FiltersAccountArgument[];
-    exclusionFilters?: FiltersAccountArgument[];
-    sort?: SortAccountArgument[];
-    highlight?: boolean;
-    aggregatorFilter?: string[];
-    scopes?: string | string[] | string[][];
-    rights?: string[];
-};
-export declare type SortAccountArgument = {
-    name?: string;
-    order?: string;
-};
-export declare type KeywordsByFieldsAccountArgument = {
-    name?: string;
-    values?: string[];
-    operator?: string;
-    type?: string;
-};
-export declare type FiltersAccountArgument = {
-    name?: string;
-    value?: string | string[];
-};
-export declare type AccountSchema = Schema<AccountAttributeType, boolean>;

package/build/account/types/accountGraphQLQueries.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=accountGraphQLQueries.js.map