@arrowsphere/api-client 3.29.0-rc.uts.1 → 3.29.0

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,62 @@
+import { SearchBodyArgument, PaginateArgument, SecurityScoreQueries } from './queryArguments';
+import { AccountsAggSchema, ChecksAggSchema, EndCustomersAggSchema, FilterSchema, MonthlyTrendAggSchema, PaginationSchema, PeriodsSchema, ScoreResultSchema, ScoresAggSchema, SeveritiesAggSchema, StandardsAggSchema, StandardSchema, StandardWithCheckSchema } 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_AVG_CURRENT_SCORE]?: boolean;
+        [GetPartnerDataFields.COLUMN_CHECKS_AGG]?: ChecksAggSchema;
+        [GetPartnerDataFields.COLUMN_END_CUSTOMERS_AGG]?: EndCustomersAggSchema;
+        [GetPartnerDataFields.COLUMN_FILTERS]?: FilterSchema;
+        [GetPartnerDataFields.COLUMN_MONTHLY_TREND_AGG]?: MonthlyTrendAggSchema;
+        [GetPartnerDataFields.COLUMN_PAGINATION]?: PaginationSchema;
+        [GetPartnerDataFields.COLUMN_PERIOD]?: PeriodsSchema;
+        [GetPartnerDataFields.COLUMN_RESULTS]?: ScoreResultSchema;
+        [GetPartnerDataFields.COLUMN_SCORES_AGG]?: ScoresAggSchema;
+        [GetPartnerDataFields.COLUMN_SEVERITIES_AGG]?: SeveritiesAggSchema;
+    };
+};
+export declare type GetCustomerDataQuery = {
+    [SecurityScoreQueries.GET_CUSTOMER_DATA]: {
+        __args?: {
+            searchBody?: SearchBodyArgument;
+            paginate?: PaginateArgument;
+        };
+        [GetCustomerDataFields.COLUMN_ACCOUNTS_AGG]?: AccountsAggSchema;
+        [GetCustomerDataFields.COLUMN_AVG_CURRENT_SCORE]?: boolean;
+        [GetCustomerDataFields.COLUMN_CHECKS_AGG]?: ChecksAggSchema;
+        [GetCustomerDataFields.COLUMN_FILTERS]?: FilterSchema;
+        [GetCustomerDataFields.COLUMN_MONTHLY_TREND_AGG]?: MonthlyTrendAggSchema;
+        [GetCustomerDataFields.COLUMN_PAGINATION]?: PaginationSchema;
+        [GetCustomerDataFields.COLUMN_PERIOD]?: PeriodsSchema;
+        [GetCustomerDataFields.COLUMN_RESULTS]?: ScoreResultSchema;
+        [GetCustomerDataFields.COLUMN_SCORES_AGG]?: ScoresAggSchema;
+        [GetCustomerDataFields.COLUMN_SEVERITIES_AGG]?: SeveritiesAggSchema;
+        [GetCustomerDataFields.COLUMN_STANDARDS]?: StandardSchema;
+        [GetCustomerDataFields.COLUMN_SUBSCRIPTION_REFERENCES]?: boolean;
+    };
+};
+export declare type GetCustomerAccountDataQuery = {
+    [SecurityScoreQueries.GET_CUSTOMER_ACCOUNT_DATA]: {
+        __args?: {
+            searchBody?: SearchBodyArgument;
+            paginate?: PaginateArgument;
+        };
+        [GetCustomerAccountDataFields.COLUMN_AVG_CURRENT_SCORE]?: boolean;
+        [GetCustomerAccountDataFields.COLUMN_CHECKS_AGG]?: ChecksAggSchema;
+        [GetCustomerAccountDataFields.COLUMN_FILTERS]?: FilterSchema;
+        [GetCustomerAccountDataFields.COLUMN_MONTHLY_TREND_AGG]?: MonthlyTrendAggSchema;
+        [GetCustomerAccountDataFields.COLUMN_PAGINATION]?: PaginationSchema;
+        [GetCustomerAccountDataFields.COLUMN_PERIOD]?: PeriodsSchema;
+        [GetCustomerAccountDataFields.COLUMN_RESULTS]?: ScoreResultSchema;
+        [GetCustomerAccountDataFields.COLUMN_SCORES_AGG]?: ScoresAggSchema;
+        [GetCustomerAccountDataFields.COLUMN_SEVERITIES_AGG]?: SeveritiesAggSchema;
+        [GetCustomerAccountDataFields.COLUMN_STANDARDS_AGG]?: StandardsAggSchema;
+        [GetCustomerAccountDataFields.COLUMN_STANDARDS]?: StandardWithCheckSchema;
+    };
+};

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

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

@@ -0,0 +1,78 @@
+import { Merge, Schema } from 'type-fest';
+import { AccountType, CheckType, FilterValuesType, MonthlyTrendAggType, PeriodsType, RegistrationType, StandardAggType, StandardType, EndCustomerByDateAggType, AccountByDateAggType, CheckAggType, PaginationsType, ScoreByDateAggType, StandardWithCheckType, ChecksByStandardType, CheckByDateType, NameCountByDateAggType, EndCustomerAggType, SeverityAggType, AccountAggType, StandardByDateAggType, ScoreByMonthAggType, ScoresAggType } from './securityScoreGraphQLTypes';
+declare type MissingFieldsOfMonthlyTrendAggSchema = {
+    scores?: Schema<ScoreByMonthAggType, boolean>;
+};
+export declare type MonthlyTrendAggSchema = Merge<Schema<MonthlyTrendAggType, boolean>, MissingFieldsOfMonthlyTrendAggSchema>;
+export declare type PaginationSchema = Schema<PaginationsType, boolean>;
+declare type EndCustomerByDateAggSchema = Schema<EndCustomerByDateAggType, boolean>;
+declare type MissingFieldsInEndCustomerAggSchema = {
+    data?: EndCustomerByDateAggSchema;
+};
+declare type EndCustomerAggSchema = Merge<Schema<EndCustomerAggType, boolean>, MissingFieldsInEndCustomerAggSchema>;
+export declare type EndCustomersAggSchema = {
+    customers?: EndCustomerAggSchema;
+};
+declare type AccountByDateAggSchema = Schema<AccountByDateAggType, boolean>;
+declare type MissingFieldsInAccountAggSchema = {
+    data?: AccountByDateAggSchema;
+};
+declare type AccountAggSchema = Merge<Schema<AccountAggType, boolean>, MissingFieldsInAccountAggSchema>;
+export declare type AccountsAggSchema = {
+    accounts?: AccountAggSchema;
+};
+declare type FilterValuesSchema = Schema<FilterValuesType, boolean>;
+export declare type FilterSchema = {
+    name?: boolean;
+    values?: FilterValuesSchema;
+};
+declare type NameCountByDateAggSchema = Schema<NameCountByDateAggType, boolean>;
+declare type MissingFieldsInCheckDataAggSchema = {
+    data?: NameCountByDateAggSchema;
+};
+declare type CheckAggAggSchema = Merge<Schema<CheckAggType, boolean>, MissingFieldsInCheckDataAggSchema>;
+export declare type ChecksAggSchema = {
+    checks?: CheckAggAggSchema;
+};
+export declare type PeriodsSchema = Schema<PeriodsType, boolean>;
+declare type CheckSchema = Schema<CheckType, boolean>;
+declare type MissingFieldsInStandardType = {
+    checks?: CheckSchema;
+};
+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 SeverityAggSchema = Merge<Schema<SeverityAggType, boolean>, MissingFieldsInCheckDataAggSchema>;
+export declare type SeveritiesAggSchema = {
+    severities?: SeverityAggSchema;
+};
+declare type StandardByDateAggSchema = Schema<StandardByDateAggType, boolean>;
+declare type MissingFieldsInStandardAggSchema = {
+    data?: StandardByDateAggSchema;
+};
+declare type StandardAggSchema = Merge<Schema<StandardAggType, boolean>, MissingFieldsInStandardAggSchema>;
+export declare type StandardsAggSchema = {
+    standards?: StandardAggSchema;
+};
+declare type ScoreByDateAggSchema = Schema<ScoreByDateAggType, boolean>;
+declare type MissingFieldsInScoresAggSchema = {
+    scores?: ScoreByDateAggSchema;
+};
+export declare type ScoresAggSchema = Merge<Schema<ScoresAggType, boolean>, MissingFieldsInScoresAggSchema>;
+declare type CheckByDateSchema = Schema<CheckByDateType, boolean>;
+declare type MissingFieldsInChecksByStandardSchema = {
+    data?: CheckByDateSchema;
+};
+declare type ChecksByStandardSchema = Merge<Schema<ChecksByStandardType, boolean>, MissingFieldsInChecksByStandardSchema>;
+declare type MissingFieldsInStandardWithCheckSchema = {
+    checks?: ChecksByStandardSchema;
+};
+export declare type StandardWithCheckSchema = Merge<Schema<StandardWithCheckType, boolean>, MissingFieldsInStandardWithCheckSchema>;
+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

@@ -0,0 +1,190 @@
+export declare type FilterType = {
+    name?: string;
+    values?: [FilterValuesType];
+};
+export declare type FilterValuesType = {
+    count?: number;
+    value?: string;
+};
+export declare type PaginationsType = {
+    currentPage?: number;
+    next?: string;
+    perPage?: number;
+    previous?: string;
+    total?: number;
+    totalPage?: number;
+};
+export declare type SubscriptionRegistrationType = {
+    reference: string;
+};
+export declare type CustomerRegistrationType = {
+    name?: string;
+    reference?: string;
+};
+export declare type ResellerRegistrationType = {
+    name?: string;
+    reference?: string;
+};
+export declare type RegistrationType = {
+    accountReference?: string;
+    customer?: CustomerRegistrationType;
+    marketplace?: string;
+    reseller?: ResellerRegistrationType;
+    subscription?: SubscriptionRegistrationType;
+    vendorCode?: string;
+};
+export declare type CheckType = {
+    description?: string;
+    flagged?: number;
+    isFailed?: boolean;
+    name?: string;
+    processed?: number;
+    reference?: string;
+    score?: number;
+    severity?: string;
+};
+export declare type StandardType = {
+    checks?: [CheckType];
+    failed?: number;
+    name?: string;
+    passed?: number;
+    reference?: string;
+    score?: number;
+    total?: number;
+};
+export declare type AccountType = {
+    failed?: number;
+    name?: string;
+    passed?: number;
+    reference?: string;
+    score?: number;
+    standards?: [StandardType];
+    total?: number;
+};
+export declare type ScoreResultType = {
+    account?: AccountType;
+    registration?: RegistrationType;
+};
+export declare type NameCountByDateAggType = {
+    count?: number;
+    date?: string;
+};
+export declare type SeverityAggType = {
+    data?: [NameCountByDateAggType];
+    last?: NameCountByDateAggType;
+    name?: string;
+    progression?: number;
+};
+export declare type SeveritiesAggType = {
+    severities: [SeverityAggType];
+};
+export declare type CheckAggType = {
+    data?: [NameCountByDateAggType];
+    last?: NameCountByDateAggType;
+    name?: string;
+    progression?: number;
+    reference?: string;
+    vendorCode?: string;
+};
+export declare type ChecksAggType = {
+    checks: [CheckAggType];
+};
+export declare type EndCustomerByDateAggType = {
+    accounts?: number;
+    avgCurrentScore?: number;
+    date?: string;
+    failed?: number;
+    passed?: number;
+    total?: number;
+    subscriptionReferences?: number;
+};
+export declare type EndCustomerAggType = {
+    data?: [EndCustomerByDateAggType];
+    last?: EndCustomerByDateAggType;
+    name?: string;
+    progression?: number;
+    reference?: string;
+};
+export declare type EndCustomersAggType = {
+    customers: [EndCustomerAggType];
+};
+export declare type ScoreByMonthAggType = {
+    avgCurrentScore?: number;
+    date?: string;
+};
+export declare type MonthlyTrendAggType = {
+    avgCurrentScore: number;
+    period: PeriodsType;
+    scores: [ScoreByMonthAggType];
+};
+export declare type ScoreByDateAggType = {
+    avgCurrentScore?: number;
+    date?: string;
+    failed?: number;
+    passed?: number;
+    total?: number;
+};
+export declare type ScoresAggType = {
+    last?: ScoreByDateAggType;
+    scores?: [ScoreByDateAggType];
+    total?: number;
+};
+export declare type AccountByDateAggType = {
+    avgCurrentScore: number;
+    date: string;
+    failed: number;
+    passed: number;
+    total?: number;
+};
+export declare type AccountAggType = {
+    data?: [AccountByDateAggType];
+    last?: AccountByDateAggType;
+    name?: string;
+    progression?: number;
+    reference?: string;
+};
+export declare type AccountsAggType = {
+    accounts: [AccountAggType];
+};
+export declare type StandardByDateAggType = {
+    date?: string;
+    score?: number;
+    failed?: number;
+    passed?: number;
+    total?: number;
+};
+export declare type StandardAggType = {
+    data?: [StandardByDateAggType];
+    last?: StandardByDateAggType;
+    name?: string;
+    progression?: number;
+    reference?: string;
+};
+export declare type StandardsAggType = {
+    standards: [StandardAggType];
+};
+export declare type CheckByDateType = {
+    date?: string;
+    flagged?: number;
+    isFailed?: boolean;
+    processed?: number;
+    score?: number;
+};
+export declare type ChecksByStandardType = {
+    data?: [CheckByDateType];
+    description?: string;
+    last?: CheckByDateType;
+    name?: string;
+    progression?: number;
+    reference?: string;
+    severity?: string;
+};
+export declare type StandardWithCheckType = {
+    checks?: [ChecksByStandardType];
+    name?: string;
+    reference?: string;
+};
+export declare type PeriodsType = {
+    from?: string;
+    to?: string;
+};

package/build/securityScore/types/securityScoreGraphQLTypes.js

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

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/ArrowSphere/nodejs-api-client.git"
   },
-  "version": "3.29.0-rc.uts.1",
+  "version": "3.29.0",
   "description": "Node.js client for ArrowSphere's public API",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -84,7 +84,9 @@
     "axios": "1.1.3",
     "graphql": "^16.3.0",
     "graphql-request": "4.2.0",
+    "json-to-graphql-query": "^2.2.5",
     "lodash": "^4.17.21",
+    "type-fest": "^2.19.0",
     "validatorjs": "3.22.1"
   }
 }