@arrowsphere/api-client 3.28.0 → 3.29.0-rc.jpb.1

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

@@ -0,0 +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

@@ -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("./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

@@ -0,0 +1,19 @@
+import { AbstractGraphQLClient } from '../abstractGraphQLClient';
+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 {
+    /**
+     * The base path of the API
+     */
+    protected basePath: string;
+    /**
+     * The Path of graphql catalog API
+     */
+    private GRAPHQL;
+    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

@@ -0,0 +1,61 @@
+"use strict";
+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);
+        /**
+         * The base path of the API
+         */
+        this.basePath = 'security/';
+        /**
+         * The Path of graphql catalog API
+         */
+        this.GRAPHQL = 'graphql/score';
+    }
+    async find(request) {
+        this.path = this.GRAPHQL;
+        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);
+        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);
+        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);
+        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;
+//# sourceMappingURL=securityScoreGraphQLClient.js.map

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

@@ -0,0 +1,108 @@
+/**
+ * For field __args
+ */
+export declare enum OperatorArgument {
+    OR = "OR",
+    AND = "AND",
+    BETWEEN = "BETWEEN"
+}
+export declare enum PeriodInputFields {
+    FROM = "from",
+    TO = "to"
+}
+export declare enum PaginateFields {
+    PAGE = "page",
+    PER_PAGE = "perPage"
+}
+export declare enum SearchBodyFields {
+    FILTERS = "filters",
+    EXCLUSION_FILTERS = "exclusionFilters",
+    SORT = "sort",
+    SUBSCRIPTION_REFERENCE = "subscriptionReference",
+    MARKETPLACE = "marketplace",
+    MONTHLY_TREND_PERIOD = "monthlyTrendPeriod",
+    PERIOD = "period"
+}
+export declare enum SearchFilterFields {
+    NAMES = "names",
+    VALUES = "values",
+    OPERATOR = "operator",
+    FILTERS = "filters"
+}
+export declare enum SearchFilterValues {
+    ACCOUNT = "account",
+    ACCOUNT_ID = "account.id",
+    ACCOUNT_REFERENCE = "account.reference",
+    ACCOUNT_NAME = "account.name",
+    ACCOUNT_STANDARDS = "account.standards",
+    ACCOUNT_STANDARDS_REFERENCE = "account.standards.reference",
+    ACCOUNT_STANDARDS_NAME = "account.standards.name",
+    ACCOUNT_STANDARDS_TOTAL = "account.standards.total",
+    ACCOUNT_STANDARDS_PASSED = "account.standards.passed",
+    ACCOUNT_STANDARDS_FAILED = "account.standards.failed",
+    ACCOUNT_STANDARDS_SCORE = "account.standards.score",
+    ACCOUNT_STANDARDS_MAX_SCORE = "account.standards.maxScore",
+    ACCOUNT_STANDARDS_CHECKS = "account.standards.checks",
+    ACCOUNT_STANDARDS_CHECKS_ID = "account.standards.checks.id",
+    ACCOUNT_STANDARDS_CHECKS_REFERENCE = "account.standards.checks.reference",
+    ACCOUNT_STANDARDS_CHECKS_NAME = "account.standards.checks.name",
+    ACCOUNT_STANDARDS_CHECKS_DESCRIPTION = "account.standards.checks.description",
+    ACCOUNT_STANDARDS_CHECKS_SEVERITY = "account.standards.checks.severity",
+    ACCOUNT_STANDARDS_CHECKS_PROCESSED = "account.standards.checks.processed",
+    ACCOUNT_STANDARDS_CHECKS_FLAGGED = "account.standards.checks.flagged",
+    ACCOUNT_STANDARDS_CHECKS_IS_FAILED = "account.standards.checks.isFailed",
+    ACCOUNT_STANDARDS_CHECKS_SCORE = "account.standards.checks.score",
+    ACCOUNT_FAILED = "account.failed",
+    ACCOUNT_PASSED = "account.passed",
+    ACCOUNT_SCORE = "account.score",
+    ACCOUNT_TOTAL = "account.total",
+    REGISTRATION = "registration",
+    REGISTRATION_ACCOUNT_REFERENCE = "registration.accountReference",
+    REGISTRATION_SUBSCRIPTION_REFERENCE = "registration.subscription.reference",
+    REGISTRATION_CUSTOMER_ID = "registration.customer.id",
+    REGISTRATION_CUSTOMER_NAME = "registration.customer.name",
+    REGISTRATION_CUSTOMER_REFERENCE = "registration.customer.reference",
+    REGISTRATION_RESELLER_ID = "registration.reseller.id",
+    REGISTRATION_RESELLER_NAME = "registration.reseller.name",
+    REGISTRATION_RESELLER_REFERENCE = "registration.reseller.reference",
+    REGISTRATION_VENDOR_CODE = "registration.vendorCode",
+    REGISTRATION_MARKETPLACE = "registration.marketplace",
+    UPDATED_AT = "updatedAt",
+    UPDATED_BY = "updatedBy"
+}
+export declare enum SortFields {
+    NAME = "name",
+    ORDER = "order"
+}
+export declare enum SecurityScoreQueries {
+    GET_PARTNER_DATA = "getPartnerData",
+    GET_CUSTOMER_DATA = "getCustomerData",
+    GET_CUSTOMER_ACCOUNT_DATA = "getCustomerAccountData"
+}
+export declare type PaginateArgument = {
+    [PaginateFields.PAGE]?: number;
+    [PaginateFields.PER_PAGE]?: number;
+};
+export declare type SearchBodyArgument = {
+    [SearchBodyFields.FILTERS]?: [SearchFilterArgument];
+    [SearchBodyFields.EXCLUSION_FILTERS]?: [SearchFilterArgument];
+    [SearchBodyFields.SORT]?: [SortArgument];
+    [SearchBodyFields.SUBSCRIPTION_REFERENCE]?: [[string]];
+    [SearchBodyFields.MARKETPLACE]?: [[string]];
+    [SearchBodyFields.MONTHLY_TREND_PERIOD]?: PeriodInputArgument;
+    [SearchBodyFields.PERIOD]?: PeriodInputArgument;
+};
+export declare type PeriodInputArgument = {
+    [PeriodInputFields.FROM]: string;
+    [PeriodInputFields.TO]: string;
+};
+export declare type SearchFilterArgument = {
+    [SearchFilterFields.NAMES]?: [string];
+    [SearchFilterFields.VALUES]?: [[string]];
+    [SearchFilterFields.OPERATOR]?: OperatorArgument;
+    [SearchFilterFields.FILTERS]?: [SearchFilterArgument];
+};
+export declare type SortArgument = {
+    [SortFields.NAME]?: string;
+    [SortFields.ORDER]?: string;
+};

package/build/securityScore/types/queryArguments.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityScoreQueries = exports.SortFields = exports.SearchFilterValues = exports.SearchFilterFields = exports.SearchBodyFields = exports.PaginateFields = exports.PeriodInputFields = exports.OperatorArgument = void 0;
+/**
+ * For field __args
+ */
+var OperatorArgument;
+(function (OperatorArgument) {
+    OperatorArgument["OR"] = "OR";
+    OperatorArgument["AND"] = "AND";
+    OperatorArgument["BETWEEN"] = "BETWEEN";
+})(OperatorArgument = exports.OperatorArgument || (exports.OperatorArgument = {}));
+var PeriodInputFields;
+(function (PeriodInputFields) {
+    PeriodInputFields["FROM"] = "from";
+    PeriodInputFields["TO"] = "to";
+})(PeriodInputFields = exports.PeriodInputFields || (exports.PeriodInputFields = {}));
+var PaginateFields;
+(function (PaginateFields) {
+    PaginateFields["PAGE"] = "page";
+    PaginateFields["PER_PAGE"] = "perPage";
+})(PaginateFields = exports.PaginateFields || (exports.PaginateFields = {}));
+var SearchBodyFields;
+(function (SearchBodyFields) {
+    SearchBodyFields["FILTERS"] = "filters";
+    SearchBodyFields["EXCLUSION_FILTERS"] = "exclusionFilters";
+    SearchBodyFields["SORT"] = "sort";
+    SearchBodyFields["SUBSCRIPTION_REFERENCE"] = "subscriptionReference";
+    SearchBodyFields["MARKETPLACE"] = "marketplace";
+    SearchBodyFields["MONTHLY_TREND_PERIOD"] = "monthlyTrendPeriod";
+    SearchBodyFields["PERIOD"] = "period";
+})(SearchBodyFields = exports.SearchBodyFields || (exports.SearchBodyFields = {}));
+var SearchFilterFields;
+(function (SearchFilterFields) {
+    SearchFilterFields["NAMES"] = "names";
+    SearchFilterFields["VALUES"] = "values";
+    SearchFilterFields["OPERATOR"] = "operator";
+    SearchFilterFields["FILTERS"] = "filters";
+})(SearchFilterFields = exports.SearchFilterFields || (exports.SearchFilterFields = {}));
+var SearchFilterValues;
+(function (SearchFilterValues) {
+    SearchFilterValues["ACCOUNT"] = "account";
+    SearchFilterValues["ACCOUNT_ID"] = "account.id";
+    SearchFilterValues["ACCOUNT_REFERENCE"] = "account.reference";
+    SearchFilterValues["ACCOUNT_NAME"] = "account.name";
+    SearchFilterValues["ACCOUNT_STANDARDS"] = "account.standards";
+    SearchFilterValues["ACCOUNT_STANDARDS_REFERENCE"] = "account.standards.reference";
+    SearchFilterValues["ACCOUNT_STANDARDS_NAME"] = "account.standards.name";
+    SearchFilterValues["ACCOUNT_STANDARDS_TOTAL"] = "account.standards.total";
+    SearchFilterValues["ACCOUNT_STANDARDS_PASSED"] = "account.standards.passed";
+    SearchFilterValues["ACCOUNT_STANDARDS_FAILED"] = "account.standards.failed";
+    SearchFilterValues["ACCOUNT_STANDARDS_SCORE"] = "account.standards.score";
+    SearchFilterValues["ACCOUNT_STANDARDS_MAX_SCORE"] = "account.standards.maxScore";
+    SearchFilterValues["ACCOUNT_STANDARDS_CHECKS"] = "account.standards.checks";
+    SearchFilterValues["ACCOUNT_STANDARDS_CHECKS_ID"] = "account.standards.checks.id";
+    SearchFilterValues["ACCOUNT_STANDARDS_CHECKS_REFERENCE"] = "account.standards.checks.reference";
+    SearchFilterValues["ACCOUNT_STANDARDS_CHECKS_NAME"] = "account.standards.checks.name";
+    SearchFilterValues["ACCOUNT_STANDARDS_CHECKS_DESCRIPTION"] = "account.standards.checks.description";
+    SearchFilterValues["ACCOUNT_STANDARDS_CHECKS_SEVERITY"] = "account.standards.checks.severity";
+    SearchFilterValues["ACCOUNT_STANDARDS_CHECKS_PROCESSED"] = "account.standards.checks.processed";
+    SearchFilterValues["ACCOUNT_STANDARDS_CHECKS_FLAGGED"] = "account.standards.checks.flagged";
+    SearchFilterValues["ACCOUNT_STANDARDS_CHECKS_IS_FAILED"] = "account.standards.checks.isFailed";
+    SearchFilterValues["ACCOUNT_STANDARDS_CHECKS_SCORE"] = "account.standards.checks.score";
+    SearchFilterValues["ACCOUNT_FAILED"] = "account.failed";
+    SearchFilterValues["ACCOUNT_PASSED"] = "account.passed";
+    SearchFilterValues["ACCOUNT_SCORE"] = "account.score";
+    SearchFilterValues["ACCOUNT_TOTAL"] = "account.total";
+    SearchFilterValues["REGISTRATION"] = "registration";
+    SearchFilterValues["REGISTRATION_ACCOUNT_REFERENCE"] = "registration.accountReference";
+    SearchFilterValues["REGISTRATION_SUBSCRIPTION_REFERENCE"] = "registration.subscription.reference";
+    SearchFilterValues["REGISTRATION_CUSTOMER_ID"] = "registration.customer.id";
+    SearchFilterValues["REGISTRATION_CUSTOMER_NAME"] = "registration.customer.name";
+    SearchFilterValues["REGISTRATION_CUSTOMER_REFERENCE"] = "registration.customer.reference";
+    SearchFilterValues["REGISTRATION_RESELLER_ID"] = "registration.reseller.id";
+    SearchFilterValues["REGISTRATION_RESELLER_NAME"] = "registration.reseller.name";
+    SearchFilterValues["REGISTRATION_RESELLER_REFERENCE"] = "registration.reseller.reference";
+    SearchFilterValues["REGISTRATION_VENDOR_CODE"] = "registration.vendorCode";
+    SearchFilterValues["REGISTRATION_MARKETPLACE"] = "registration.marketplace";
+    SearchFilterValues["UPDATED_AT"] = "updatedAt";
+    SearchFilterValues["UPDATED_BY"] = "updatedBy";
+})(SearchFilterValues = exports.SearchFilterValues || (exports.SearchFilterValues = {}));
+var SortFields;
+(function (SortFields) {
+    SortFields["NAME"] = "name";
+    SortFields["ORDER"] = "order";
+})(SortFields = exports.SortFields || (exports.SortFields = {}));
+var SecurityScoreQueries;
+(function (SecurityScoreQueries) {
+    SecurityScoreQueries["GET_PARTNER_DATA"] = "getPartnerData";
+    SecurityScoreQueries["GET_CUSTOMER_DATA"] = "getCustomerData";
+    SecurityScoreQueries["GET_CUSTOMER_ACCOUNT_DATA"] = "getCustomerAccountData";
+})(SecurityScoreQueries = exports.SecurityScoreQueries || (exports.SecurityScoreQueries = {}));
+//# sourceMappingURL=queryArguments.js.map

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

@@ -0,0 +1,55 @@
+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 = {
+    [SecurityScoreQueries.GET_PARTNER_DATA]: {
+        __args?: {
+            searchBody?: SearchBodyArgument;
+            paginate?: PaginateArgument;
+        };
+        [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 = {
+    [SecurityScoreQueries.GET_CUSTOMER_DATA]: {
+        __args?: {
+            searchBody?: SearchBodyArgument;
+        };
+        [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 = {
+    [SecurityScoreQueries.GET_CUSTOMER_ACCOUNT_DATA]: {
+        __args?: {
+            searchBody?: SearchBodyArgument;
+        };
+        [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

@@ -0,0 +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