@arrowsphere/api-client 3.28.0-rc.bdj.3 → 3.28.0-rc.bdj.5

package/build/securityScore/entities/getCustomerAccountData.d.ts

@@ -0,0 +1,44 @@
+import { AbstractEntity } from '../../abstractEntity';
+import { CheckByStandardType, FilterType, ScoreResultType, MonthlyTrendAggType, IssuesAggType, SeveritiesAggType, PeriodsType, StandardType, StandardsAggType } from '../types/securityScoreGraphQLTypes';
+import { SecurityScoreQueries } from '../types/queryArguments';
+export declare enum GetCustomerAccountDataFields {
+    COLUMN_AVG_CURRENT_SCORE = "avgCurrentScore",
+    COLUMN_CHECKS = "checks",
+    COLUMN_FILTERS = "filters",
+    COLUMN_ISSUE_AGG = "issueAgg",
+    COLUMN_MONTHLY_TREND_AGG = "monthlyTrendAgg",
+    COLUMN_PERIOD = "period",
+    COLUMN_RESULT = "result",
+    COLUMN_SEVERITY_AGG = "severityAgg",
+    COLUMN_STANDARDS_AGG = "standardsAgg",
+    COLUMN_STANDARDS = "standards"
+}
+export declare type GetCustomerAccountDataType = {
+    [GetCustomerAccountDataFields.COLUMN_AVG_CURRENT_SCORE]?: number;
+    [GetCustomerAccountDataFields.COLUMN_CHECKS]?: [CheckByStandardType];
+    [GetCustomerAccountDataFields.COLUMN_FILTERS]?: [FilterType];
+    [GetCustomerAccountDataFields.COLUMN_ISSUE_AGG]?: IssuesAggType;
+    [GetCustomerAccountDataFields.COLUMN_MONTHLY_TREND_AGG]?: MonthlyTrendAggType;
+    [GetCustomerAccountDataFields.COLUMN_PERIOD]?: PeriodsType;
+    [GetCustomerAccountDataFields.COLUMN_RESULT]?: ScoreResultType;
+    [GetCustomerAccountDataFields.COLUMN_SEVERITY_AGG]?: SeveritiesAggType;
+    [GetCustomerAccountDataFields.COLUMN_STANDARDS_AGG]?: StandardsAggType;
+    [GetCustomerAccountDataFields.COLUMN_STANDARDS]?: [StandardType];
+};
+export declare type GetCustomerAccountDataGraphQLResultType = {
+    [SecurityScoreQueries.GET_CUSTOMER_ACCOUNT_DATA]: GetCustomerAccountDataType;
+};
+export declare class GetCustomerAccountData extends AbstractEntity<GetCustomerAccountDataType> {
+    #private;
+    constructor(getCustomerAccountDataInput: GetCustomerAccountDataType);
+    get avgCurrentScore(): number | undefined;
+    get checks(): [CheckByStandardType] | undefined;
+    get filters(): [FilterType] | undefined;
+    get issueAgg(): IssuesAggType | undefined;
+    get monthlyTrendAgg(): MonthlyTrendAggType | undefined;
+    get period(): PeriodsType | undefined;
+    get result(): ScoreResultType | undefined;
+    get standardsAgg(): StandardsAggType | undefined;
+    get standards(): [StandardType] | undefined;
+    toJSON(): GetCustomerAccountDataType;
+}

package/build/securityScore/entities/getCustomerAccountData.js

@@ -0,0 +1,99 @@
+"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 _GetCustomerAccountData_avgCurrentScore, _GetCustomerAccountData_checks, _GetCustomerAccountData_filters, _GetCustomerAccountData_issueAgg, _GetCustomerAccountData_monthlyTrendAgg, _GetCustomerAccountData_period, _GetCustomerAccountData_result, _GetCustomerAccountData_severityAgg, _GetCustomerAccountData_standardsAgg, _GetCustomerAccountData_standards;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetCustomerAccountData = exports.GetCustomerAccountDataFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+const queryArguments_1 = require("../types/queryArguments");
+var GetCustomerAccountDataFields;
+(function (GetCustomerAccountDataFields) {
+    GetCustomerAccountDataFields["COLUMN_AVG_CURRENT_SCORE"] = "avgCurrentScore";
+    GetCustomerAccountDataFields["COLUMN_CHECKS"] = "checks";
+    GetCustomerAccountDataFields["COLUMN_FILTERS"] = "filters";
+    GetCustomerAccountDataFields["COLUMN_ISSUE_AGG"] = "issueAgg";
+    GetCustomerAccountDataFields["COLUMN_MONTHLY_TREND_AGG"] = "monthlyTrendAgg";
+    GetCustomerAccountDataFields["COLUMN_PERIOD"] = "period";
+    GetCustomerAccountDataFields["COLUMN_RESULT"] = "result";
+    GetCustomerAccountDataFields["COLUMN_SEVERITY_AGG"] = "severityAgg";
+    GetCustomerAccountDataFields["COLUMN_STANDARDS_AGG"] = "standardsAgg";
+    GetCustomerAccountDataFields["COLUMN_STANDARDS"] = "standards";
+})(GetCustomerAccountDataFields = exports.GetCustomerAccountDataFields || (exports.GetCustomerAccountDataFields = {}));
+class GetCustomerAccountData extends abstractEntity_1.AbstractEntity {
+    constructor(getCustomerAccountDataInput) {
+        super(getCustomerAccountDataInput);
+        _GetCustomerAccountData_avgCurrentScore.set(this, void 0);
+        _GetCustomerAccountData_checks.set(this, void 0);
+        _GetCustomerAccountData_filters.set(this, void 0);
+        _GetCustomerAccountData_issueAgg.set(this, void 0);
+        _GetCustomerAccountData_monthlyTrendAgg.set(this, void 0);
+        _GetCustomerAccountData_period.set(this, void 0);
+        _GetCustomerAccountData_result.set(this, void 0);
+        _GetCustomerAccountData_severityAgg.set(this, void 0);
+        _GetCustomerAccountData_standardsAgg.set(this, void 0);
+        _GetCustomerAccountData_standards.set(this, void 0);
+        __classPrivateFieldSet(this, _GetCustomerAccountData_avgCurrentScore, getCustomerAccountDataInput[GetCustomerAccountDataFields.COLUMN_AVG_CURRENT_SCORE], "f");
+        __classPrivateFieldSet(this, _GetCustomerAccountData_checks, getCustomerAccountDataInput[GetCustomerAccountDataFields.COLUMN_CHECKS], "f");
+        __classPrivateFieldSet(this, _GetCustomerAccountData_filters, getCustomerAccountDataInput[GetCustomerAccountDataFields.COLUMN_FILTERS], "f");
+        __classPrivateFieldSet(this, _GetCustomerAccountData_issueAgg, getCustomerAccountDataInput[GetCustomerAccountDataFields.COLUMN_ISSUE_AGG], "f");
+        __classPrivateFieldSet(this, _GetCustomerAccountData_monthlyTrendAgg, getCustomerAccountDataInput[GetCustomerAccountDataFields.COLUMN_MONTHLY_TREND_AGG], "f");
+        __classPrivateFieldSet(this, _GetCustomerAccountData_period, getCustomerAccountDataInput[GetCustomerAccountDataFields.COLUMN_PERIOD], "f");
+        __classPrivateFieldSet(this, _GetCustomerAccountData_result, getCustomerAccountDataInput[GetCustomerAccountDataFields.COLUMN_RESULT], "f");
+        __classPrivateFieldSet(this, _GetCustomerAccountData_severityAgg, getCustomerAccountDataInput[GetCustomerAccountDataFields.COLUMN_SEVERITY_AGG], "f");
+        __classPrivateFieldSet(this, _GetCustomerAccountData_standardsAgg, getCustomerAccountDataInput[GetCustomerAccountDataFields.COLUMN_STANDARDS_AGG], "f");
+        __classPrivateFieldSet(this, _GetCustomerAccountData_standards, getCustomerAccountDataInput[GetCustomerAccountDataFields.COLUMN_STANDARDS], "f");
+    }
+    get avgCurrentScore() {
+        return __classPrivateFieldGet(this, _GetCustomerAccountData_avgCurrentScore, "f");
+    }
+    get checks() {
+        return __classPrivateFieldGet(this, _GetCustomerAccountData_checks, "f");
+    }
+    get filters() {
+        return __classPrivateFieldGet(this, _GetCustomerAccountData_filters, "f");
+    }
+    get issueAgg() {
+        return __classPrivateFieldGet(this, _GetCustomerAccountData_issueAgg, "f");
+    }
+    get monthlyTrendAgg() {
+        return __classPrivateFieldGet(this, _GetCustomerAccountData_monthlyTrendAgg, "f");
+    }
+    get period() {
+        return __classPrivateFieldGet(this, _GetCustomerAccountData_period, "f");
+    }
+    get result() {
+        return __classPrivateFieldGet(this, _GetCustomerAccountData_result, "f");
+    }
+    get standardsAgg() {
+        return __classPrivateFieldGet(this, _GetCustomerAccountData_standardsAgg, "f");
+    }
+    get standards() {
+        return __classPrivateFieldGet(this, _GetCustomerAccountData_standards, "f");
+    }
+    toJSON() {
+        return {
+            [GetCustomerAccountDataFields.COLUMN_AVG_CURRENT_SCORE]: __classPrivateFieldGet(this, _GetCustomerAccountData_avgCurrentScore, "f"),
+            [GetCustomerAccountDataFields.COLUMN_CHECKS]: __classPrivateFieldGet(this, _GetCustomerAccountData_checks, "f"),
+            [GetCustomerAccountDataFields.COLUMN_FILTERS]: __classPrivateFieldGet(this, _GetCustomerAccountData_filters, "f"),
+            [GetCustomerAccountDataFields.COLUMN_ISSUE_AGG]: __classPrivateFieldGet(this, _GetCustomerAccountData_issueAgg, "f"),
+            [GetCustomerAccountDataFields.COLUMN_MONTHLY_TREND_AGG]: __classPrivateFieldGet(this, _GetCustomerAccountData_monthlyTrendAgg, "f"),
+            [GetCustomerAccountDataFields.COLUMN_PERIOD]: __classPrivateFieldGet(this, _GetCustomerAccountData_period, "f"),
+            [GetCustomerAccountDataFields.COLUMN_RESULT]: __classPrivateFieldGet(this, _GetCustomerAccountData_result, "f"),
+            [GetCustomerAccountDataFields.COLUMN_SEVERITY_AGG]: __classPrivateFieldGet(this, _GetCustomerAccountData_severityAgg, "f"),
+            [GetCustomerAccountDataFields.COLUMN_STANDARDS_AGG]: __classPrivateFieldGet(this, _GetCustomerAccountData_standardsAgg, "f"),
+            [GetCustomerAccountDataFields.COLUMN_STANDARDS]: __classPrivateFieldGet(this, _GetCustomerAccountData_standards, "f"),
+        };
+    }
+}
+exports.GetCustomerAccountData = GetCustomerAccountData;
+_GetCustomerAccountData_avgCurrentScore = new WeakMap(), _GetCustomerAccountData_checks = new WeakMap(), _GetCustomerAccountData_filters = new WeakMap(), _GetCustomerAccountData_issueAgg = new WeakMap(), _GetCustomerAccountData_monthlyTrendAgg = new WeakMap(), _GetCustomerAccountData_period = new WeakMap(), _GetCustomerAccountData_result = new WeakMap(), _GetCustomerAccountData_severityAgg = new WeakMap(), _GetCustomerAccountData_standardsAgg = new WeakMap(), _GetCustomerAccountData_standards = new WeakMap();
+//# sourceMappingURL=getCustomerAccountData.js.map

package/build/securityScore/entities/getCustomerData.d.ts

@@ -0,0 +1,44 @@
+import { AbstractEntity } from '../../abstractEntity';
+import { AccountsAggType, FilterType, ScoreResultType, MonthlyTrendAggType, IssuesAggType, SeveritiesAggType, PeriodsType, StandardType } from '../types/securityScoreGraphQLTypes';
+import { SecurityScoreQueries } from '../types/queryArguments';
+export declare enum GetCustomerDataFields {
+    COLUMN_ACCOUNTS_AGG = "accountsAgg",
+    COLUMN_AVG_CURRENT_SCORE = "avgCurrentScore",
+    COLUMN_FILTERS = "filters",
+    COLUMN_MONTHLY_TREND_AGG = "monthlyTrendAgg",
+    COLUMN_PERIOD = "period",
+    COLUMN_RESULTS = "results",
+    COLUMN_ISSUE_AGG = "issueAgg",
+    COLUMN_SEVERITY_AGG = "severityAgg",
+    COLUMN_STANDARDS = "standards",
+    COLUMN_SUBSCRIPTION_REFERENCES = "subscriptionReferences"
+}
+export declare type GetCustomerDataType = {
+    [GetCustomerDataFields.COLUMN_ACCOUNTS_AGG]?: AccountsAggType;
+    [GetCustomerDataFields.COLUMN_AVG_CURRENT_SCORE]?: number;
+    [GetCustomerDataFields.COLUMN_FILTERS]?: [FilterType];
+    [GetCustomerDataFields.COLUMN_MONTHLY_TREND_AGG]?: MonthlyTrendAggType;
+    [GetCustomerDataFields.COLUMN_PERIOD]?: PeriodsType;
+    [GetCustomerDataFields.COLUMN_RESULTS]?: [ScoreResultType];
+    [GetCustomerDataFields.COLUMN_ISSUE_AGG]?: IssuesAggType;
+    [GetCustomerDataFields.COLUMN_SEVERITY_AGG]?: SeveritiesAggType;
+    [GetCustomerDataFields.COLUMN_STANDARDS]?: [StandardType];
+    [GetCustomerDataFields.COLUMN_SUBSCRIPTION_REFERENCES]?: number;
+};
+export declare type GetCustomerDataGraphQLResultType = {
+    [SecurityScoreQueries.GET_CUSTOMER_DATA]: GetCustomerDataType;
+};
+export declare class GetCustomerData extends AbstractEntity<GetCustomerDataType> {
+    #private;
+    constructor(getCustomerDataInput: GetCustomerDataType);
+    get accountsAgg(): AccountsAggType | undefined;
+    get avgCurrentScore(): number | undefined;
+    get filters(): [FilterType] | undefined;
+    get monthlyTrendAgg(): MonthlyTrendAggType | undefined;
+    get period(): PeriodsType | undefined;
+    get results(): [ScoreResultType] | undefined;
+    get issueAgg(): IssuesAggType | undefined;
+    get standards(): [StandardType] | undefined;
+    get subscriptionReferences(): number | undefined;
+    toJSON(): GetCustomerDataType;
+}

package/build/securityScore/entities/getCustomerData.js

@@ -0,0 +1,99 @@
+"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 _GetCustomerData_accountsAgg, _GetCustomerData_avgCurrentScore, _GetCustomerData_filters, _GetCustomerData_monthlyTrendAgg, _GetCustomerData_period, _GetCustomerData_results, _GetCustomerData_issueAgg, _GetCustomerData_severityAgg, _GetCustomerData_standards, _GetCustomerData_subscriptionReferences;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetCustomerData = exports.GetCustomerDataFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+const queryArguments_1 = require("../types/queryArguments");
+var GetCustomerDataFields;
+(function (GetCustomerDataFields) {
+    GetCustomerDataFields["COLUMN_ACCOUNTS_AGG"] = "accountsAgg";
+    GetCustomerDataFields["COLUMN_AVG_CURRENT_SCORE"] = "avgCurrentScore";
+    GetCustomerDataFields["COLUMN_FILTERS"] = "filters";
+    GetCustomerDataFields["COLUMN_MONTHLY_TREND_AGG"] = "monthlyTrendAgg";
+    GetCustomerDataFields["COLUMN_PERIOD"] = "period";
+    GetCustomerDataFields["COLUMN_RESULTS"] = "results";
+    GetCustomerDataFields["COLUMN_ISSUE_AGG"] = "issueAgg";
+    GetCustomerDataFields["COLUMN_SEVERITY_AGG"] = "severityAgg";
+    GetCustomerDataFields["COLUMN_STANDARDS"] = "standards";
+    GetCustomerDataFields["COLUMN_SUBSCRIPTION_REFERENCES"] = "subscriptionReferences";
+})(GetCustomerDataFields = exports.GetCustomerDataFields || (exports.GetCustomerDataFields = {}));
+class GetCustomerData extends abstractEntity_1.AbstractEntity {
+    constructor(getCustomerDataInput) {
+        super(getCustomerDataInput);
+        _GetCustomerData_accountsAgg.set(this, void 0);
+        _GetCustomerData_avgCurrentScore.set(this, void 0);
+        _GetCustomerData_filters.set(this, void 0);
+        _GetCustomerData_monthlyTrendAgg.set(this, void 0);
+        _GetCustomerData_period.set(this, void 0);
+        _GetCustomerData_results.set(this, void 0);
+        _GetCustomerData_issueAgg.set(this, void 0);
+        _GetCustomerData_severityAgg.set(this, void 0);
+        _GetCustomerData_standards.set(this, void 0);
+        _GetCustomerData_subscriptionReferences.set(this, void 0);
+        __classPrivateFieldSet(this, _GetCustomerData_accountsAgg, getCustomerDataInput[GetCustomerDataFields.COLUMN_ACCOUNTS_AGG], "f");
+        __classPrivateFieldSet(this, _GetCustomerData_avgCurrentScore, getCustomerDataInput[GetCustomerDataFields.COLUMN_AVG_CURRENT_SCORE], "f");
+        __classPrivateFieldSet(this, _GetCustomerData_filters, getCustomerDataInput[GetCustomerDataFields.COLUMN_FILTERS], "f");
+        __classPrivateFieldSet(this, _GetCustomerData_monthlyTrendAgg, getCustomerDataInput[GetCustomerDataFields.COLUMN_MONTHLY_TREND_AGG], "f");
+        __classPrivateFieldSet(this, _GetCustomerData_period, getCustomerDataInput[GetCustomerDataFields.COLUMN_PERIOD], "f");
+        __classPrivateFieldSet(this, _GetCustomerData_results, getCustomerDataInput[GetCustomerDataFields.COLUMN_RESULTS], "f");
+        __classPrivateFieldSet(this, _GetCustomerData_issueAgg, getCustomerDataInput[GetCustomerDataFields.COLUMN_ISSUE_AGG], "f");
+        __classPrivateFieldSet(this, _GetCustomerData_severityAgg, getCustomerDataInput[GetCustomerDataFields.COLUMN_SEVERITY_AGG], "f");
+        __classPrivateFieldSet(this, _GetCustomerData_standards, getCustomerDataInput[GetCustomerDataFields.COLUMN_STANDARDS], "f");
+        __classPrivateFieldSet(this, _GetCustomerData_subscriptionReferences, getCustomerDataInput[GetCustomerDataFields.COLUMN_SUBSCRIPTION_REFERENCES], "f");
+    }
+    get accountsAgg() {
+        return __classPrivateFieldGet(this, _GetCustomerData_accountsAgg, "f");
+    }
+    get avgCurrentScore() {
+        return __classPrivateFieldGet(this, _GetCustomerData_avgCurrentScore, "f");
+    }
+    get filters() {
+        return __classPrivateFieldGet(this, _GetCustomerData_filters, "f");
+    }
+    get monthlyTrendAgg() {
+        return __classPrivateFieldGet(this, _GetCustomerData_monthlyTrendAgg, "f");
+    }
+    get period() {
+        return __classPrivateFieldGet(this, _GetCustomerData_period, "f");
+    }
+    get results() {
+        return __classPrivateFieldGet(this, _GetCustomerData_results, "f");
+    }
+    get issueAgg() {
+        return __classPrivateFieldGet(this, _GetCustomerData_issueAgg, "f");
+    }
+    get standards() {
+        return __classPrivateFieldGet(this, _GetCustomerData_standards, "f");
+    }
+    get subscriptionReferences() {
+        return __classPrivateFieldGet(this, _GetCustomerData_subscriptionReferences, "f");
+    }
+    toJSON() {
+        return {
+            [GetCustomerDataFields.COLUMN_ACCOUNTS_AGG]: __classPrivateFieldGet(this, _GetCustomerData_accountsAgg, "f"),
+            [GetCustomerDataFields.COLUMN_AVG_CURRENT_SCORE]: __classPrivateFieldGet(this, _GetCustomerData_avgCurrentScore, "f"),
+            [GetCustomerDataFields.COLUMN_FILTERS]: __classPrivateFieldGet(this, _GetCustomerData_filters, "f"),
+            [GetCustomerDataFields.COLUMN_MONTHLY_TREND_AGG]: __classPrivateFieldGet(this, _GetCustomerData_monthlyTrendAgg, "f"),
+            [GetCustomerDataFields.COLUMN_PERIOD]: __classPrivateFieldGet(this, _GetCustomerData_period, "f"),
+            [GetCustomerDataFields.COLUMN_RESULTS]: __classPrivateFieldGet(this, _GetCustomerData_results, "f"),
+            [GetCustomerDataFields.COLUMN_ISSUE_AGG]: __classPrivateFieldGet(this, _GetCustomerData_issueAgg, "f"),
+            [GetCustomerDataFields.COLUMN_SEVERITY_AGG]: __classPrivateFieldGet(this, _GetCustomerData_severityAgg, "f"),
+            [GetCustomerDataFields.COLUMN_STANDARDS]: __classPrivateFieldGet(this, _GetCustomerData_standards, "f"),
+            [GetCustomerDataFields.COLUMN_SUBSCRIPTION_REFERENCES]: __classPrivateFieldGet(this, _GetCustomerData_subscriptionReferences, "f"),
+        };
+    }
+}
+exports.GetCustomerData = GetCustomerData;
+_GetCustomerData_accountsAgg = new WeakMap(), _GetCustomerData_avgCurrentScore = new WeakMap(), _GetCustomerData_filters = new WeakMap(), _GetCustomerData_monthlyTrendAgg = new WeakMap(), _GetCustomerData_period = new WeakMap(), _GetCustomerData_results = new WeakMap(), _GetCustomerData_issueAgg = new WeakMap(), _GetCustomerData_severityAgg = new WeakMap(), _GetCustomerData_standards = new WeakMap(), _GetCustomerData_subscriptionReferences = new WeakMap();
+//# sourceMappingURL=getCustomerData.js.map

package/build/securityScore/entities/getPartnerData.d.ts

@@ -0,0 +1,39 @@
+import { AbstractEntity } from '../../abstractEntity';
+import { FilterType, ScoreResultType, MonthlyTrendAggType, EndCustomersAggType, IssuesAggType, SeveritiesAggType, PeriodsType } from '../types/securityScoreGraphQLTypes';
+import { SecurityScoreQueries } from '../types/queryArguments';
+export declare enum GetPartnerDataFields {
+    COLUMN_FILTERS = "filters",
+    COLUMN_RESULTS = "results",
+    COLUMN_AVG_CURRENT_SCORE = "avgCurrentScore",
+    COLUMN_MONTHLY_TREND_AGG = "monthlyTrendAgg",
+    COLUMN_END_CUSTOMERS_AGG = "endCustomersAgg",
+    COLUMN_ISSUE_AGG = "issueAgg",
+    COLUMN_SEVERITY_AGG = "severityAgg",
+    COLUMN_PERIOD = "period"
+}
+export declare type GetPartnerDataType = {
+    [GetPartnerDataFields.COLUMN_FILTERS]?: [FilterType];
+    [GetPartnerDataFields.COLUMN_RESULTS]?: [ScoreResultType];
+    [GetPartnerDataFields.COLUMN_AVG_CURRENT_SCORE]?: number;
+    [GetPartnerDataFields.COLUMN_MONTHLY_TREND_AGG]?: MonthlyTrendAggType;
+    [GetPartnerDataFields.COLUMN_END_CUSTOMERS_AGG]?: EndCustomersAggType;
+    [GetPartnerDataFields.COLUMN_ISSUE_AGG]?: IssuesAggType;
+    [GetPartnerDataFields.COLUMN_SEVERITY_AGG]?: SeveritiesAggType;
+    [GetPartnerDataFields.COLUMN_PERIOD]?: PeriodsType;
+};
+export declare type GetPartnerDataGraphQLResultType = {
+    [SecurityScoreQueries.GET_PARTNER_DATA]: GetPartnerDataType;
+};
+export declare class GetPartnerData extends AbstractEntity<GetPartnerDataType> {
+    #private;
+    constructor(getPartnerDataInput: GetPartnerDataType);
+    get filters(): [FilterType] | undefined;
+    get results(): [ScoreResultType] | undefined;
+    get avgCurrentScore(): number | undefined;
+    get monthlyTrendAgg(): MonthlyTrendAggType | undefined;
+    get endCustomersAgg(): EndCustomersAggType | undefined;
+    get issueAgg(): IssuesAggType | undefined;
+    get severityAgg(): SeveritiesAggType | undefined;
+    get period(): PeriodsType | undefined;
+    toJSON(): GetPartnerDataType;
+}

package/build/securityScore/entities/getPartnerData.js

@@ -0,0 +1,88 @@
+"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 _GetPartnerData_filters, _GetPartnerData_results, _GetPartnerData_avgCurrentScore, _GetPartnerData_monthlyTrendAgg, _GetPartnerData_endCustomersAgg, _GetPartnerData_issueAgg, _GetPartnerData_severityAgg, _GetPartnerData_period;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPartnerData = exports.GetPartnerDataFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+const queryArguments_1 = require("../types/queryArguments");
+var GetPartnerDataFields;
+(function (GetPartnerDataFields) {
+    GetPartnerDataFields["COLUMN_FILTERS"] = "filters";
+    GetPartnerDataFields["COLUMN_RESULTS"] = "results";
+    GetPartnerDataFields["COLUMN_AVG_CURRENT_SCORE"] = "avgCurrentScore";
+    GetPartnerDataFields["COLUMN_MONTHLY_TREND_AGG"] = "monthlyTrendAgg";
+    GetPartnerDataFields["COLUMN_END_CUSTOMERS_AGG"] = "endCustomersAgg";
+    GetPartnerDataFields["COLUMN_ISSUE_AGG"] = "issueAgg";
+    GetPartnerDataFields["COLUMN_SEVERITY_AGG"] = "severityAgg";
+    GetPartnerDataFields["COLUMN_PERIOD"] = "period";
+})(GetPartnerDataFields = exports.GetPartnerDataFields || (exports.GetPartnerDataFields = {}));
+class GetPartnerData extends abstractEntity_1.AbstractEntity {
+    constructor(getPartnerDataInput) {
+        super(getPartnerDataInput);
+        _GetPartnerData_filters.set(this, void 0);
+        _GetPartnerData_results.set(this, void 0);
+        _GetPartnerData_avgCurrentScore.set(this, void 0);
+        _GetPartnerData_monthlyTrendAgg.set(this, void 0);
+        _GetPartnerData_endCustomersAgg.set(this, void 0);
+        _GetPartnerData_issueAgg.set(this, void 0);
+        _GetPartnerData_severityAgg.set(this, void 0);
+        _GetPartnerData_period.set(this, void 0);
+        __classPrivateFieldSet(this, _GetPartnerData_filters, getPartnerDataInput[GetPartnerDataFields.COLUMN_FILTERS], "f");
+        __classPrivateFieldSet(this, _GetPartnerData_results, getPartnerDataInput[GetPartnerDataFields.COLUMN_RESULTS], "f");
+        __classPrivateFieldSet(this, _GetPartnerData_avgCurrentScore, getPartnerDataInput[GetPartnerDataFields.COLUMN_AVG_CURRENT_SCORE], "f");
+        __classPrivateFieldSet(this, _GetPartnerData_monthlyTrendAgg, getPartnerDataInput[GetPartnerDataFields.COLUMN_MONTHLY_TREND_AGG], "f");
+        __classPrivateFieldSet(this, _GetPartnerData_endCustomersAgg, getPartnerDataInput[GetPartnerDataFields.COLUMN_END_CUSTOMERS_AGG], "f");
+        __classPrivateFieldSet(this, _GetPartnerData_issueAgg, getPartnerDataInput[GetPartnerDataFields.COLUMN_ISSUE_AGG], "f");
+        __classPrivateFieldSet(this, _GetPartnerData_severityAgg, getPartnerDataInput[GetPartnerDataFields.COLUMN_SEVERITY_AGG], "f");
+        __classPrivateFieldSet(this, _GetPartnerData_period, getPartnerDataInput[GetPartnerDataFields.COLUMN_PERIOD], "f");
+    }
+    get filters() {
+        return __classPrivateFieldGet(this, _GetPartnerData_filters, "f");
+    }
+    get results() {
+        return __classPrivateFieldGet(this, _GetPartnerData_results, "f");
+    }
+    get avgCurrentScore() {
+        return __classPrivateFieldGet(this, _GetPartnerData_avgCurrentScore, "f");
+    }
+    get monthlyTrendAgg() {
+        return __classPrivateFieldGet(this, _GetPartnerData_monthlyTrendAgg, "f");
+    }
+    get endCustomersAgg() {
+        return __classPrivateFieldGet(this, _GetPartnerData_endCustomersAgg, "f");
+    }
+    get issueAgg() {
+        return __classPrivateFieldGet(this, _GetPartnerData_issueAgg, "f");
+    }
+    get severityAgg() {
+        return __classPrivateFieldGet(this, _GetPartnerData_severityAgg, "f");
+    }
+    get period() {
+        return __classPrivateFieldGet(this, _GetPartnerData_period, "f");
+    }
+    toJSON() {
+        return {
+            [GetPartnerDataFields.COLUMN_FILTERS]: __classPrivateFieldGet(this, _GetPartnerData_filters, "f"),
+            [GetPartnerDataFields.COLUMN_RESULTS]: __classPrivateFieldGet(this, _GetPartnerData_results, "f"),
+            [GetPartnerDataFields.COLUMN_AVG_CURRENT_SCORE]: __classPrivateFieldGet(this, _GetPartnerData_avgCurrentScore, "f"),
+            [GetPartnerDataFields.COLUMN_MONTHLY_TREND_AGG]: __classPrivateFieldGet(this, _GetPartnerData_monthlyTrendAgg, "f"),
+            [GetPartnerDataFields.COLUMN_END_CUSTOMERS_AGG]: __classPrivateFieldGet(this, _GetPartnerData_endCustomersAgg, "f"),
+            [GetPartnerDataFields.COLUMN_ISSUE_AGG]: __classPrivateFieldGet(this, _GetPartnerData_issueAgg, "f"),
+            [GetPartnerDataFields.COLUMN_SEVERITY_AGG]: __classPrivateFieldGet(this, _GetPartnerData_severityAgg, "f"),
+            [GetPartnerDataFields.COLUMN_PERIOD]: __classPrivateFieldGet(this, _GetPartnerData_period, "f"),
+        };
+    }
+}
+exports.GetPartnerData = GetPartnerData;
+_GetPartnerData_filters = new WeakMap(), _GetPartnerData_results = new WeakMap(), _GetPartnerData_avgCurrentScore = new WeakMap(), _GetPartnerData_monthlyTrendAgg = new WeakMap(), _GetPartnerData_endCustomersAgg = new WeakMap(), _GetPartnerData_issueAgg = new WeakMap(), _GetPartnerData_severityAgg = new WeakMap(), _GetPartnerData_period = new WeakMap();
+//# sourceMappingURL=getPartnerData.js.map

package/build/securityScore/index.d.ts

@@ -1,2 +1,7 @@
 export * from './securityScoreGraphQLClient';
+export * from './types/securityScoreGraphQLQueries';
 export * from './types/securityScoreGraphQLTypes';
+export * from './types/queryArguments';
+export * from './entities/getPartnerData';
+export * from './entities/getCustomerData';
+export * from './entities/getCustomerAccountData';

package/build/securityScore/index.js

@@ -15,5 +15,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./securityScoreGraphQLClient"), exports);
+__exportStar(require("./types/securityScoreGraphQLQueries"), exports);
 __exportStar(require("./types/securityScoreGraphQLTypes"), exports);
+__exportStar(require("./types/queryArguments"), exports);
+__exportStar(require("./entities/getPartnerData"), exports);
+__exportStar(require("./entities/getCustomerData"), exports);
+__exportStar(require("./entities/getCustomerAccountData"), exports);
 //# sourceMappingURL=index.js.map

package/build/securityScore/securityScoreGraphQLClient.d.ts

@@ -1,5 +1,7 @@
 import { AbstractGraphQLClient } from '../abstractGraphQLClient';
-import { GetPartnerDataType, GetCustomerDataType, GetCustomerAccountDataType } from './types/securityScoreGraphQLTypes';
+import { GetPartnerDataType } from './entities/getPartnerData';
+import { GetCustomerDataType } from './entities/getCustomerData';
+import { GetCustomerAccountDataType } from './entities/getCustomerAccountData';
 import { GetPartnerDataQuery, GetCustomerDataQuery, GetCustomerAccountDataQuery } from './types/securityScoreGraphQLQueries';
 export declare class SecurityScoreGraphQLClient extends AbstractGraphQLClient {
     /**
@@ -10,8 +12,8 @@ export declare class SecurityScoreGraphQLClient extends AbstractGraphQLClient {
      * The Path of graphql catalog API
      */
     private GRAPHQL;
-    find<GraphQLResponseTypes>(request: string): Promise<GraphQLResponseTypes>;
-    getPartnerData(getPartnerDataQuery: GetPartnerDataQuery): Promise<GetPartnerDataType>;
-    getCustomerData(getCustomerDataQuery: GetCustomerDataQuery): Promise<GetCustomerDataType>;
-    getCustomerAccountData(getCustomerAccountDataQuery: GetCustomerAccountDataQuery): Promise<GetCustomerAccountDataType>;
+    find<GraphQLResponseTypes>(request: string): Promise<GraphQLResponseTypes | null>;
+    getPartnerData(getPartnerDataQuery: GetPartnerDataQuery): Promise<GetPartnerDataType | null>;
+    getCustomerData(getCustomerDataQuery: GetCustomerDataQuery): Promise<GetCustomerDataType | null>;
+    getCustomerAccountData(getCustomerAccountDataQuery: GetCustomerAccountDataQuery): Promise<GetCustomerAccountDataType | null>;
 }

package/build/securityScore/securityScoreGraphQLClient.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SecurityScoreGraphQLClient = void 0;
 const abstractGraphQLClient_1 = require("../abstractGraphQLClient");
+const getPartnerData_1 = require("./entities/getPartnerData");
+const getCustomerData_1 = require("./entities/getCustomerData");
+const getCustomerAccountData_1 = require("./entities/getCustomerAccountData");
+const queryArguments_1 = require("./types/queryArguments");
 class SecurityScoreGraphQLClient extends abstractGraphQLClient_1.AbstractGraphQLClient {
     constructor() {
         super(...arguments);
@@ -16,19 +20,41 @@ class SecurityScoreGraphQLClient extends abstractGraphQLClient_1.AbstractGraphQL
     }
     async find(request) {
         this.path = this.GRAPHQL;
-        return await this.post(request);
+        try {
+            return await this.post(request);
+        }
+        catch (error) {
+            const exception = this.mapToPublicApiException(error);
+            const { mustRetry } = await this.handleError(exception);
+            if (mustRetry) {
+                return await this.post(request);
+            }
+        }
+        return null;
     }
     async getPartnerData(getPartnerDataQuery) {
         const queryStr = this.stringifyQuery(getPartnerDataQuery);
-        return this.find(queryStr);
+        const getPartnerDataResult = await this.find(queryStr);
+        if (getPartnerDataResult) {
+            return new getPartnerData_1.GetPartnerData(getPartnerDataResult[queryArguments_1.SecurityScoreQueries.GET_PARTNER_DATA]).toJSON();
+        }
+        return null;
     }
     async getCustomerData(getCustomerDataQuery) {
         const queryStr = this.stringifyQuery(getCustomerDataQuery);
-        return this.find(queryStr);
+        const getCustomerDataResult = await this.find(queryStr);
+        if (getCustomerDataResult) {
+            return new getCustomerData_1.GetCustomerData(getCustomerDataResult[queryArguments_1.SecurityScoreQueries.GET_CUSTOMER_DATA]).toJSON();
+        }
+        return null;
     }
     async getCustomerAccountData(getCustomerAccountDataQuery) {
         const queryStr = this.stringifyQuery(getCustomerAccountDataQuery);
-        return this.find(queryStr);
+        const getCustomerAccountDataResult = await this.find(queryStr);
+        if (getCustomerAccountDataResult) {
+            return new getCustomerAccountData_1.GetCustomerAccountData(getCustomerAccountDataResult[queryArguments_1.SecurityScoreQueries.GET_CUSTOMER_ACCOUNT_DATA]).toJSON();
+        }
+        return null;
     }
 }
 exports.SecurityScoreGraphQLClient = SecurityScoreGraphQLClient;

package/build/securityScore/types/securityScoreGraphQLQueries.d.ts

@@ -1,50 +1,55 @@
-import { SearchBodyArgument, PaginateArgument } from './queryArguments';
-import { AccountsAggType, CheckType, EndCustomersAggType, FilterType, IssuesAggType, MonthlyTrendAggType, PeriodsType, ScoreResultType, SeveritiesAggType, StandardsAggType, StandardType } from './securityScoreGraphQLTypes';
+import { SearchBodyArgument, PaginateArgument, SecurityScoreQueries } from './queryArguments';
+import { AccountsAggSchema, CheckByStandardSchema, EndCustomersAggSchema, FilterSchema, IssuesAggSchema, MonthlyTrendAggSchema, PeriodsSchema, ScoreResultSchema, SeveritiesAggSchema, StandardsAggSchema, StandardSchema } from './securityScoreGraphQLSchemas';
+import { GetPartnerDataFields } from '../entities/getPartnerData';
+import { GetCustomerDataFields } from '../entities/getCustomerData';
+import { GetCustomerAccountDataFields } from '../entities/getCustomerAccountData';
 export declare type GetPartnerDataQuery = {
-    getPartnerData: {
+    [SecurityScoreQueries.GET_PARTNER_DATA]: {
         __args?: {
             searchBody?: SearchBodyArgument;
             paginate?: PaginateArgument;
         };
-        filters?: [FilterType];
-        results?: [ScoreResultType];
-        avgCurrentScore?: number;
-        monthlyTrendAgg?: MonthlyTrendAggType;
-        endCustomersAgg?: EndCustomersAggType;
-        issueAgg?: IssuesAggType;
-        severityAgg?: SeveritiesAggType;
-        period?: PeriodsType;
+        [GetPartnerDataFields.COLUMN_FILTERS]?: FilterSchema;
+        [GetPartnerDataFields.COLUMN_RESULTS]?: ScoreResultSchema;
+        [GetPartnerDataFields.COLUMN_AVG_CURRENT_SCORE]?: boolean;
+        [GetPartnerDataFields.COLUMN_MONTHLY_TREND_AGG]?: MonthlyTrendAggSchema;
+        [GetPartnerDataFields.COLUMN_END_CUSTOMERS_AGG]?: EndCustomersAggSchema;
+        [GetPartnerDataFields.COLUMN_ISSUE_AGG]?: IssuesAggSchema;
+        [GetPartnerDataFields.COLUMN_SEVERITY_AGG]?: SeveritiesAggSchema;
+        [GetPartnerDataFields.COLUMN_PERIOD]?: PeriodsSchema;
     };
 };
 export declare type GetCustomerDataQuery = {
-    getCustomerData: {
+    [SecurityScoreQueries.GET_CUSTOMER_DATA]: {
         __args?: {
             searchBody?: SearchBodyArgument;
         };
-        accountsAgg?: AccountsAggType;
-        avgCurrentScore?: number;
-        filters?: [FilterType];
-        monthlyTrendAgg?: MonthlyTrendAggType;
-        period?: PeriodsType;
-        results?: [ScoreResultType];
-        severityAgg?: SeveritiesAggType;
-        standards?: [StandardType];
-        subscriptionReferences?: number;
+        [GetCustomerDataFields.COLUMN_FILTERS]?: FilterSchema;
+        [GetCustomerDataFields.COLUMN_ACCOUNTS_AGG]?: AccountsAggSchema;
+        [GetCustomerDataFields.COLUMN_SEVERITY_AGG]?: SeveritiesAggSchema;
+        [GetCustomerDataFields.COLUMN_PERIOD]?: PeriodsSchema;
+        [GetCustomerDataFields.COLUMN_AVG_CURRENT_SCORE]?: boolean;
+        [GetCustomerDataFields.COLUMN_MONTHLY_TREND_AGG]?: MonthlyTrendAggSchema;
+        [GetCustomerDataFields.COLUMN_ISSUE_AGG]?: IssuesAggSchema;
+        [GetCustomerDataFields.COLUMN_RESULTS]?: ScoreResultSchema;
+        [GetCustomerDataFields.COLUMN_STANDARDS]?: StandardSchema;
+        [GetCustomerDataFields.COLUMN_SUBSCRIPTION_REFERENCES]?: boolean;
     };
 };
 export declare type GetCustomerAccountDataQuery = {
-    getCustomerAccountData: {
+    [SecurityScoreQueries.GET_CUSTOMER_ACCOUNT_DATA]: {
         __args?: {
             searchBody?: SearchBodyArgument;
         };
-        avgCurrentScore?: boolean;
-        checks?: [CheckType];
-        filters?: [FilterType];
-        monthlyTrendAgg?: MonthlyTrendAggType;
-        period?: PeriodsType;
-        result?: ScoreResultType;
-        severityAgg?: SeveritiesAggType;
-        standardsAgg?: StandardsAggType;
-        standards?: [StandardType];
+        [GetCustomerAccountDataFields.COLUMN_FILTERS]?: [FilterSchema];
+        [GetCustomerAccountDataFields.COLUMN_ISSUE_AGG]?: IssuesAggSchema;
+        [GetCustomerAccountDataFields.COLUMN_AVG_CURRENT_SCORE]?: boolean;
+        [GetCustomerAccountDataFields.COLUMN_STANDARDS_AGG]?: StandardsAggSchema;
+        [GetCustomerAccountDataFields.COLUMN_SEVERITY_AGG]?: SeveritiesAggSchema;
+        [GetCustomerAccountDataFields.COLUMN_PERIOD]?: PeriodsSchema;
+        [GetCustomerAccountDataFields.COLUMN_CHECKS]?: CheckByStandardSchema;
+        [GetCustomerAccountDataFields.COLUMN_MONTHLY_TREND_AGG]?: MonthlyTrendAggSchema;
+        [GetCustomerAccountDataFields.COLUMN_RESULT]?: ScoreResultSchema;
+        [GetCustomerAccountDataFields.COLUMN_STANDARDS]?: StandardSchema;
     };
 };

package/build/securityScore/types/securityScoreGraphQLQueries.js

@@ -1,3 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const queryArguments_1 = require("./queryArguments");
+const getPartnerData_1 = require("../entities/getPartnerData");
+const getCustomerData_1 = require("../entities/getCustomerData");
+const getCustomerAccountData_1 = require("../entities/getCustomerAccountData");
 //# sourceMappingURL=securityScoreGraphQLQueries.js.map

package/build/securityScore/types/securityScoreGraphQLSchemas.d.ts

@@ -0,0 +1,71 @@
+import { Merge, Schema } from 'type-fest';
+import { AccountType, CheckType, CheckByStandardType, CompareAccountAggType, CompareEndCustomerAggType, CompareStandardAggType, FilterValuesType, IssueDataAggType, MonthlyTrendAggType, NameCountByDateType, PeriodsType, RegistrationType, ScoreByMonthType, StandardAggType, StandardType } from './securityScoreGraphQLTypes';
+declare type MissingFieldsOfMonthlyTrendAggSchema = {
+    scores?: Schema<ScoreByMonthType, boolean>;
+};
+export declare type MonthlyTrendAggSchema = Merge<Schema<MonthlyTrendAggType, boolean>, MissingFieldsOfMonthlyTrendAggSchema>;
+declare type CompareEndCustomerAggSchema = Schema<CompareEndCustomerAggType, boolean>;
+declare type EndCustomerAggSchema = {
+    reference?: boolean;
+    name?: boolean;
+    data?: CompareEndCustomerAggSchema;
+    progression?: boolean;
+};
+export declare type EndCustomersAggSchema = {
+    customers: EndCustomerAggSchema;
+};
+declare type CompareAccountAggSchema = Schema<CompareAccountAggType, boolean>;
+export declare type AccountAggSchema = {
+    accountRef?: boolean;
+    data?: CompareAccountAggSchema;
+    progression?: boolean;
+};
+export declare type AccountsAggSchema = {
+    accounts: AccountAggSchema;
+};
+declare type FilterValuesSchema = Schema<FilterValuesType, boolean>;
+export declare type FilterSchema = {
+    name?: boolean;
+    values?: FilterValuesSchema;
+};
+declare type NameCountByDateSchema = Schema<NameCountByDateType, boolean>;
+declare type NameAggSchema = {
+    name?: boolean;
+    data?: NameCountByDateSchema;
+    progression?: boolean;
+};
+declare type MissingFieldsInIssueDataAggSchema = {
+    data?: NameCountByDateSchema;
+};
+declare type IssueDataAggSchema = Merge<Schema<IssueDataAggType, boolean>, MissingFieldsInIssueDataAggSchema>;
+export declare type IssuesAggSchema = {
+    issues: IssueDataAggSchema;
+};
+export declare type PeriodsSchema = Schema<PeriodsType, boolean>;
+export declare type CheckByStandardSchema = Schema<CheckByStandardType, boolean>;
+declare type MissingFieldsInStandardType = {
+    checks?: CheckSchema;
+};
+export declare type CheckSchema = Schema<CheckType, boolean>;
+export declare type StandardSchema = Merge<Schema<StandardType, boolean>, MissingFieldsInStandardType>;
+declare type MissingFieldsInAccountSchema = {
+    standards: StandardSchema;
+};
+declare type AccountSchema = Merge<Schema<AccountType, boolean>, MissingFieldsInAccountSchema>;
+declare type RegistrationSchema = Schema<RegistrationType, boolean>;
+export declare type ScoreResultSchema = {
+    account?: AccountSchema;
+    registration?: RegistrationSchema;
+};
+export declare type SeveritiesAggSchema = {
+    severities: NameAggSchema;
+};
+declare type CompareStandardAggSchema = Schema<CompareStandardAggType, boolean>;
+declare type MissingFieldsInStandardAggSchema = {
+    data?: CompareStandardAggSchema;
+};
+declare type StandardAggSchema = Merge<Schema<StandardAggType, boolean>, MissingFieldsInStandardAggSchema>;
+export declare type StandardsAggSchema = {
+    standards: StandardAggSchema;
+};
+export {};

package/build/securityScore/types/securityScoreGraphQLSchemas.js

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

package/build/securityScore/types/securityScoreGraphQLTypes.d.ts

@@ -37,6 +37,7 @@ export declare type CheckType = {
 };
 export declare type StandardType = {
     name?: string;
+    reference?: string;
     checks?: [CheckType];
     failed?: number;
     passed?: number;
@@ -63,12 +64,14 @@ export declare type NameCountByDateType = {
 export declare type NameAggType = {
     name?: string;
     data?: [NameCountByDateType];
+    last?: NameCountByDateType;
     progression?: number;
 };
 export declare type IssueDataAggType = {
     name?: string;
     reference?: string;
     vendorCode?: string;
+    last?: NameCountByDateType;
     data?: [NameCountByDateType];
     progression?: number;
 };
@@ -108,16 +111,6 @@ export declare type MonthlyTrendAggType = {
     avgCurrentScore?: number;
     scores?: [ScoreByMonthType];
 };
-export declare type GetPartnerDataType = {
-    filters?: [FilterType];
-    results?: [ScoreResultType];
-    avgCurrentScore?: number;
-    monthlyTrendAgg?: MonthlyTrendAggType;
-    endCustomersAgg?: EndCustomersAggType;
-    issueAgg?: IssuesAggType;
-    severityAgg?: SeveritiesAggType;
-    period?: PeriodsType;
-};
 export declare type CompareAccountAggType = {
     date?: string;
     avgCurrentScore?: number;
@@ -125,25 +118,15 @@ export declare type CompareAccountAggType = {
     passed?: number;
 };
 export declare type AccountAggType = {
-    accountRef?: string;
+    name?: string;
+    last?: CompareAccountAggType;
+    reference?: string;
     data?: [CompareAccountAggType];
     progression?: number;
 };
 export declare type AccountsAggType = {
     accounts: [AccountAggType];
 };
-export declare type GetCustomerDataType = {
-    accountsAgg?: AccountsAggType;
-    avgCurrentScore?: number;
-    filters?: [FilterType];
-    monthlyTrendAgg?: MonthlyTrendAggType;
-    period?: PeriodsType;
-    results?: [ScoreResultType];
-    issueAgg?: IssuesAggType;
-    severityAgg?: SeveritiesAggType;
-    standards?: [StandardType];
-    subscriptionReferences?: number;
-};
 export declare type CompareStandardAggType = {
     date?: string;
     score?: number;
@@ -153,21 +136,30 @@ export declare type CompareStandardAggType = {
 export declare type StandardAggType = {
     name?: string;
     reference?: string;
+    last?: CompareStandardAggType;
     data?: [CompareStandardAggType];
     progression?: number;
 };
 export declare type StandardsAggType = {
     standards: [StandardAggType];
 };
-export declare type GetCustomerAccountDataType = {
-    avgCurrentScore?: number;
-    checks?: [CheckType];
-    filters?: [FilterType];
-    issueAgg?: IssuesAggType;
-    monthlyTrendAgg?: MonthlyTrendAggType;
-    period?: PeriodsType;
-    result?: ScoreResultType;
-    severityAgg?: SeveritiesAggType;
-    standardsAgg?: StandardsAggType;
-    standards?: [StandardType];
+export declare type CompareCheckType = {
+    date?: string;
+    processed?: number;
+    isFailed?: boolean;
+    flagged?: number;
+    score?: number;
+};
+export declare type ChecksByStandardType = {
+    data?: [CompareCheckType];
+    last?: CompareCheckType;
+    name?: string;
+    description?: string;
+    reference?: string;
+    severity?: string;
+    progression?: number;
+};
+export declare type CheckByStandardType = {
+    standard?: string;
+    checks?: [ChecksByStandardType];
 };

package/package.json

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