@arrowsphere/api-client 3.53.0 → 3.53.1

package/build/index.d.ts

@@ -21,7 +21,7 @@ export * from './shared/';
 export * from './security/';
 export * from './subscriptions/';
 export * from './supportCenter/';
+export * from './securityScore/';
 export * from './user/';
-export * from './wellArchitected/';
 export { ContactInformation };
 import * as ContactInformation from './contact';

package/build/index.js

@@ -50,9 +50,8 @@ __exportStar(require("./shared/"), exports);
 __exportStar(require("./security/"), exports);
 __exportStar(require("./subscriptions/"), exports);
 __exportStar(require("./supportCenter/"), exports);
-// export * from './securityScore/';
+__exportStar(require("./securityScore/"), exports);
 __exportStar(require("./user/"), exports);
-__exportStar(require("./wellArchitected/"), exports);
 const ContactInformation = __importStar(require("./contact"));
 exports.ContactInformation = ContactInformation;
 //# sourceMappingURL=index.js.map

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

@@ -1,6 +1,10 @@
 import { AbstractEntity } from '../../abstractEntity';
 import { ChecksAggType, MarketplacesAggType, MonthlyTrendAggType, PaginationsType, PartnersAggType, PeriodsType, ScoreResultType, ScoresAggType, SeveritiesAggType } from '../types/securityScoreGraphQLTypes';
 import { SecurityScoreQueries } from '../types/queryArguments';
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare enum GetAdminDataFields {
     COLUMN_CHECKS_AGG = "checksAgg",
     COLUMN_MARKETPLACES_AGG = "marketplacesAgg",
@@ -12,6 +16,10 @@ export declare enum GetAdminDataFields {
     COLUMN_SCORES_AGG = "scoresAgg",
     COLUMN_SEVERITIES_AGG = "severitiesAgg"
 }
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type GetAdminDataType = {
     [GetAdminDataFields.COLUMN_CHECKS_AGG]?: ChecksAggType;
     [GetAdminDataFields.COLUMN_MARKETPLACES_AGG]?: MarketplacesAggType;
@@ -23,9 +31,17 @@ export declare type GetAdminDataType = {
     [GetAdminDataFields.COLUMN_SCORES_AGG]?: ScoresAggType;
     [GetAdminDataFields.COLUMN_SEVERITIES_AGG]?: SeveritiesAggType;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type GetAdminDataGraphQLResultType = {
     [SecurityScoreQueries.GET_ADMIN_DATA]: GetAdminDataType;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent class in the wellArchitected
+ */
 export declare class GetAdminData extends AbstractEntity<GetAdminDataType> {
     #private;
     constructor(getAdminDataInput: GetAdminDataType);

package/build/securityScore/entities/getAdminData.js

@@ -15,6 +15,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetAdminData = exports.GetAdminDataFields = void 0;
 const abstractEntity_1 = require("../../abstractEntity");
 const queryArguments_1 = require("../types/queryArguments");
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 var GetAdminDataFields;
 (function (GetAdminDataFields) {
     GetAdminDataFields["COLUMN_CHECKS_AGG"] = "checksAgg";
@@ -27,6 +31,10 @@ var GetAdminDataFields;
     GetAdminDataFields["COLUMN_SCORES_AGG"] = "scoresAgg";
     GetAdminDataFields["COLUMN_SEVERITIES_AGG"] = "severitiesAgg";
 })(GetAdminDataFields = exports.GetAdminDataFields || (exports.GetAdminDataFields = {}));
+/**
+ * @deprecated
+ * Prefer using equivalent class in the wellArchitected
+ */
 class GetAdminData extends abstractEntity_1.AbstractEntity {
     constructor(getAdminDataInput) {
         super(getAdminDataInput);

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

@@ -1,6 +1,10 @@
 import { AbstractEntity } from '../../abstractEntity';
 import { ChecksAggType, MonthlyTrendAggType, PaginationsType, PeriodsType, ScoreResultType, ScoresAggType, SeveritiesAggType, StandardsAggType, StandardWithCheckType } from '../types/securityScoreGraphQLTypes';
 import { SecurityScoreQueries } from '../types/queryArguments';
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare enum GetCustomerAccountDataFields {
     COLUMN_CHECKS_AGG = "checksAgg",
     COLUMN_MONTHLY_TREND_AGG = "monthlyTrendAgg",
@@ -12,6 +16,10 @@ export declare enum GetCustomerAccountDataFields {
     COLUMN_STANDARDS_AGG = "standardsAgg",
     COLUMN_STANDARDS = "standards"
 }
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type GetCustomerAccountDataType = {
     [GetCustomerAccountDataFields.COLUMN_CHECKS_AGG]?: ChecksAggType;
     [GetCustomerAccountDataFields.COLUMN_MONTHLY_TREND_AGG]?: MonthlyTrendAggType;
@@ -23,9 +31,17 @@ export declare type GetCustomerAccountDataType = {
     [GetCustomerAccountDataFields.COLUMN_STANDARDS_AGG]?: StandardsAggType;
     [GetCustomerAccountDataFields.COLUMN_STANDARDS]?: StandardWithCheckType[];
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type GetCustomerAccountDataGraphQLResultType = {
     [SecurityScoreQueries.GET_CUSTOMER_ACCOUNT_DATA]: GetCustomerAccountDataType;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare class GetCustomerAccountData extends AbstractEntity<GetCustomerAccountDataType> {
     #private;
     constructor(getCustomerAccountDataInput: GetCustomerAccountDataType);

package/build/securityScore/entities/getCustomerAccountData.js

@@ -15,6 +15,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetCustomerAccountData = exports.GetCustomerAccountDataFields = void 0;
 const abstractEntity_1 = require("../../abstractEntity");
 const queryArguments_1 = require("../types/queryArguments");
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 var GetCustomerAccountDataFields;
 (function (GetCustomerAccountDataFields) {
     GetCustomerAccountDataFields["COLUMN_CHECKS_AGG"] = "checksAgg";
@@ -27,6 +31,10 @@ var GetCustomerAccountDataFields;
     GetCustomerAccountDataFields["COLUMN_STANDARDS_AGG"] = "standardsAgg";
     GetCustomerAccountDataFields["COLUMN_STANDARDS"] = "standards";
 })(GetCustomerAccountDataFields = exports.GetCustomerAccountDataFields || (exports.GetCustomerAccountDataFields = {}));
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 class GetCustomerAccountData extends abstractEntity_1.AbstractEntity {
     constructor(getCustomerAccountDataInput) {
         super(getCustomerAccountDataInput);

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

@@ -1,6 +1,10 @@
 import { AbstractEntity } from '../../abstractEntity';
 import { AccountsAggType, ScoreResultType, MonthlyTrendAggType, SeveritiesAggType, PaginationsType, PeriodsType, ChecksAggType, ScoresAggType, StandardWithCheckType } from '../types/securityScoreGraphQLTypes';
 import { SecurityScoreQueries } from '../types/queryArguments';
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare enum GetCustomerDataFields {
     COLUMN_ACCOUNTS_AGG = "accountsAgg",
     COLUMN_CHECKS_AGG = "checksAgg",
@@ -13,6 +17,10 @@ export declare enum GetCustomerDataFields {
     COLUMN_STANDARDS = "standards",
     COLUMN_SUBSCRIPTION_REFERENCES = "subscriptionReferences"
 }
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type GetCustomerDataType = {
     [GetCustomerDataFields.COLUMN_ACCOUNTS_AGG]?: AccountsAggType;
     [GetCustomerDataFields.COLUMN_CHECKS_AGG]?: ChecksAggType;
@@ -25,9 +33,17 @@ export declare type GetCustomerDataType = {
     [GetCustomerDataFields.COLUMN_STANDARDS]?: StandardWithCheckType[];
     [GetCustomerDataFields.COLUMN_SUBSCRIPTION_REFERENCES]?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type GetCustomerDataGraphQLResultType = {
     [SecurityScoreQueries.GET_CUSTOMER_DATA]: GetCustomerDataType;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare class GetCustomerData extends AbstractEntity<GetCustomerDataType> {
     #private;
     constructor(getCustomerDataInput: GetCustomerDataType);

package/build/securityScore/entities/getCustomerData.js

@@ -15,6 +15,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetCustomerData = exports.GetCustomerDataFields = void 0;
 const abstractEntity_1 = require("../../abstractEntity");
 const queryArguments_1 = require("../types/queryArguments");
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 var GetCustomerDataFields;
 (function (GetCustomerDataFields) {
     GetCustomerDataFields["COLUMN_ACCOUNTS_AGG"] = "accountsAgg";
@@ -28,6 +32,10 @@ var GetCustomerDataFields;
     GetCustomerDataFields["COLUMN_STANDARDS"] = "standards";
     GetCustomerDataFields["COLUMN_SUBSCRIPTION_REFERENCES"] = "subscriptionReferences";
 })(GetCustomerDataFields = exports.GetCustomerDataFields || (exports.GetCustomerDataFields = {}));
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 class GetCustomerData extends abstractEntity_1.AbstractEntity {
     constructor(getCustomerDataInput) {
         super(getCustomerDataInput);

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

@@ -1,6 +1,10 @@
 import { AbstractEntity } from '../../abstractEntity';
 import { ChecksAggType, EndCustomersAggType, MarketplacesAggType, MonthlyTrendAggType, PaginationsType, PeriodsType, ScoreResultType, ScoresAggType, SeveritiesAggType } from '../types/securityScoreGraphQLTypes';
 import { SecurityScoreQueries } from '../types/queryArguments';
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare enum GetPartnerDataFields {
     COLUMN_CHECKS_AGG = "checksAgg",
     COLUMN_END_CUSTOMERS_AGG = "endCustomersAgg",
@@ -12,6 +16,10 @@ export declare enum GetPartnerDataFields {
     COLUMN_SCORES_AGG = "scoresAgg",
     COLUMN_SEVERITIES_AGG = "severitiesAgg"
 }
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type GetPartnerDataType = {
     [GetPartnerDataFields.COLUMN_CHECKS_AGG]?: ChecksAggType;
     [GetPartnerDataFields.COLUMN_END_CUSTOMERS_AGG]?: EndCustomersAggType;
@@ -23,9 +31,17 @@ export declare type GetPartnerDataType = {
     [GetPartnerDataFields.COLUMN_SCORES_AGG]?: ScoresAggType;
     [GetPartnerDataFields.COLUMN_SEVERITIES_AGG]?: SeveritiesAggType;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type GetPartnerDataGraphQLResultType = {
     [SecurityScoreQueries.GET_PARTNER_DATA]: GetPartnerDataType;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare class GetPartnerData extends AbstractEntity<GetPartnerDataType> {
     #private;
     constructor(getPartnerDataInput: GetPartnerDataType);

package/build/securityScore/entities/getPartnerData.js

@@ -15,6 +15,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetPartnerData = exports.GetPartnerDataFields = void 0;
 const abstractEntity_1 = require("../../abstractEntity");
 const queryArguments_1 = require("../types/queryArguments");
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 var GetPartnerDataFields;
 (function (GetPartnerDataFields) {
     GetPartnerDataFields["COLUMN_CHECKS_AGG"] = "checksAgg";
@@ -27,6 +31,10 @@ var GetPartnerDataFields;
     GetPartnerDataFields["COLUMN_SCORES_AGG"] = "scoresAgg";
     GetPartnerDataFields["COLUMN_SEVERITIES_AGG"] = "severitiesAgg";
 })(GetPartnerDataFields = exports.GetPartnerDataFields || (exports.GetPartnerDataFields = {}));
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 class GetPartnerData extends abstractEntity_1.AbstractEntity {
     constructor(getPartnerDataInput) {
         super(getPartnerDataInput);

package/build/securityScore/securityScoreGraphQLClient.d.ts

@@ -4,6 +4,10 @@ import { GetCustomerDataType } from './entities/getCustomerData';
 import { GetCustomerAccountDataType } from './entities/getCustomerAccountData';
 import { GetPartnerDataQuery, GetCustomerDataQuery, GetCustomerAccountDataQuery, GetAdminDataQuery } from './types/securityScoreGraphQLQueries';
 import { GetAdminDataType } from './entities/getAdminData';
+/**
+ * @deprecated
+ * Prefer using equivalent class in the wellArchitected -> WellArchitectedGraphQLClient
+ */
 export declare class SecurityScoreGraphQLClient extends AbstractGraphQLClient {
     /**
      * The base path of the API

package/build/securityScore/securityScoreGraphQLClient.js

@@ -7,6 +7,10 @@ const getCustomerData_1 = require("./entities/getCustomerData");
 const getCustomerAccountData_1 = require("./entities/getCustomerAccountData");
 const queryArguments_1 = require("./types/queryArguments");
 const getAdminData_1 = require("./entities/getAdminData");
+/**
+ * @deprecated
+ * Prefer using equivalent class in the wellArchitected -> WellArchitectedGraphQLClient
+ */
 class SecurityScoreGraphQLClient extends abstractGraphQLClient_1.AbstractGraphQLClient {
     constructor() {
         super(...arguments);

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

@@ -6,6 +6,10 @@ export declare enum OperatorArgument {
     AND = "AND",
     BETWEEN = "BETWEEN"
 }
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare enum PeriodInputFields {
     FROM = "from",
     TO = "to"

package/build/securityScore/types/queryArguments.js

@@ -10,6 +10,10 @@ var OperatorArgument;
     OperatorArgument["AND"] = "AND";
     OperatorArgument["BETWEEN"] = "BETWEEN";
 })(OperatorArgument = exports.OperatorArgument || (exports.OperatorArgument = {}));
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 var PeriodInputFields;
 (function (PeriodInputFields) {
     PeriodInputFields["FROM"] = "from";

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

@@ -4,6 +4,10 @@ import { GetPartnerDataFields } from '../entities/getPartnerData';
 import { GetCustomerDataFields } from '../entities/getCustomerData';
 import { GetCustomerAccountDataFields } from '../entities/getCustomerAccountData';
 import { GetAdminDataFields } from '../entities/getAdminData';
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type GetPartnerDataQuery = {
     [SecurityScoreQueries.GET_PARTNER_DATA]: {
         __args?: {
@@ -21,6 +25,10 @@ export declare type GetPartnerDataQuery = {
         [GetPartnerDataFields.COLUMN_SEVERITIES_AGG]?: SeveritiesAggSchema;
     };
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type GetCustomerDataQuery = {
     [SecurityScoreQueries.GET_CUSTOMER_DATA]: {
         __args?: {
@@ -39,6 +47,10 @@ export declare type GetCustomerDataQuery = {
         [GetCustomerDataFields.COLUMN_SUBSCRIPTION_REFERENCES]?: boolean;
     };
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type GetCustomerAccountDataQuery = {
     [SecurityScoreQueries.GET_CUSTOMER_ACCOUNT_DATA]: {
         __args?: {
@@ -56,6 +68,10 @@ export declare type GetCustomerAccountDataQuery = {
         [GetCustomerAccountDataFields.COLUMN_STANDARDS]?: StandardWithCheckSchema;
     };
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type GetAdminDataQuery = {
     [SecurityScoreQueries.GET_ADMIN_DATA]: {
         __args?: {

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

@@ -3,7 +3,15 @@ import { AccountType, CheckType, FilterValuesType, MonthlyTrendAggType, PeriodsT
 declare type MissingFieldsOfMonthlyTrendAggSchema = {
     scores?: Schema<ScoreByMonthAggType, boolean>;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type MonthlyTrendAggSchema = Merge<Schema<MonthlyTrendAggType, boolean>, MissingFieldsOfMonthlyTrendAggSchema>;
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type PaginationSchema = Schema<PaginationsType, boolean>;
 declare type EndCustomerByDateAggSchema = Schema<EndCustomerByDateAggType, boolean>;
 declare type MissingFieldsInEndCustomerAggSchema = {
@@ -25,6 +33,10 @@ declare type MissingFieldsInUnregisteredEndCustomerAggSchema = {
     offers?: UnregisteredOffersSchema;
 };
 declare type UnregisteredEndCustomerAggSchema = Merge<UnregisteredEndCustomerAggTypeSchema, MissingFieldsInUnregisteredEndCustomerAggSchema>;
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type EndCustomersAggSchema = {
     customers?: EndCustomerAggSchema;
     unregisteredCustomers?: UnregisteredEndCustomerAggSchema;
@@ -34,11 +46,19 @@ declare type MissingFieldsInAccountAggSchema = {
     data?: AccountByDateAggSchema;
 };
 declare type AccountAggSchema = Merge<Schema<AccountAggType, boolean>, MissingFieldsInAccountAggSchema>;
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type AccountsAggSchema = {
     accounts?: AccountAggSchema;
     unregisteredAccounts?: UnregisteredOffersSchema;
 };
 declare type FilterValuesSchema = Schema<FilterValuesType, boolean>;
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type FilterSchema = {
     name?: boolean;
     values?: FilterValuesSchema;
@@ -52,25 +72,49 @@ declare type MissingFieldsInCheckAggSchema = {
     data?: CheckCountByDateAggSchema;
 };
 declare type CheckAggSchema = Merge<Schema<CheckAggType, boolean>, MissingFieldsInCheckAggSchema>;
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type ChecksAggSchema = {
     checks?: CheckAggSchema;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type PeriodsSchema = Schema<PeriodsType, boolean>;
 declare type CheckSchema = Schema<CheckType, boolean>;
 declare type MissingFieldsInStandardType = {
     checks?: CheckSchema;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 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>;
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type ScoreResultSchema = {
     account?: AccountSchema;
     registration?: RegistrationSchema;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type SeverityAggSchema = Merge<Schema<SeverityAggType, boolean>, MissingFieldsInSeverityAggSchema>;
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type SeveritiesAggSchema = {
     severities?: SeverityAggSchema;
 };
@@ -79,6 +123,10 @@ declare type MissingFieldsInStandardAggSchema = {
     data?: StandardByDateAggSchema;
 };
 declare type StandardAggSchema = Merge<Schema<StandardAggType, boolean>, MissingFieldsInStandardAggSchema>;
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type StandardsAggSchema = {
     standards?: StandardAggSchema;
 };
@@ -86,6 +134,10 @@ declare type ScoreByDateAggSchema = Schema<ScoreByDateAggType, boolean>;
 declare type MissingFieldsInScoresAggSchema = {
     scores?: ScoreByDateAggSchema;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type ScoresAggSchema = Merge<Schema<ScoresAggType, boolean>, MissingFieldsInScoresAggSchema>;
 declare type CheckByDateSchema = Schema<CheckByDateType, boolean>;
 declare type MissingFieldsInChecksByStandardSchema = {
@@ -95,6 +147,10 @@ declare type ChecksByStandardSchema = Merge<Schema<ChecksByStandardType, boolean
 declare type MissingFieldsInStandardWithCheckSchema = {
     checks?: ChecksByStandardSchema;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type StandardWithCheckSchema = Merge<Schema<StandardWithCheckType, boolean>, MissingFieldsInStandardWithCheckSchema>;
 declare type MarketplacePartnerAggByDateAggSchema = Schema<MarketplacePartnerAggByDateAggType, boolean>;
 declare type MissingFieldsInMarketplacePartnerAggSchema = {
@@ -107,6 +163,10 @@ declare type MissingFieldsInMarketplaceAggSchema = {
     partners?: MarketplacePartnerAggSchema;
 };
 declare type MarketplaceAggSchema = Merge<Schema<MarketplaceAggType, boolean>, MissingFieldsInMarketplaceAggSchema>;
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type MarketplacesAggSchema = {
     marketplaces?: MarketplaceAggSchema;
 };
@@ -115,6 +175,10 @@ declare type MissingFieldsInPartnerAggSchema = {
     data?: PartnerByDateAggTypeSchema;
 };
 declare type PartnerAggSchema = Merge<Schema<PartnerAggType, boolean>, MissingFieldsInPartnerAggSchema>;
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type PartnersAggSchema = {
     partners?: PartnerAggSchema;
 };

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

@@ -1,11 +1,23 @@
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type FilterType = {
     name?: string;
     values?: FilterValuesType[];
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type FilterValuesType = {
     count?: number;
     value?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type PaginationsType = {
     currentPage?: number;
     next?: string;
@@ -14,17 +26,33 @@ export declare type PaginationsType = {
     total?: number;
     totalPage?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type SubscriptionRegistrationType = {
     reference: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type CustomerRegistrationType = {
     name?: string;
     reference?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type ResellerRegistrationType = {
     name?: string;
     reference?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type RegistrationType = {
     accountReference?: string;
     customer?: CustomerRegistrationType;
@@ -33,6 +61,10 @@ export declare type RegistrationType = {
     subscription?: SubscriptionRegistrationType;
     vendorCode?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type CheckType = {
     description?: string;
     flagged?: number;
@@ -44,6 +76,10 @@ export declare type CheckType = {
     score?: number;
     severity?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type StandardType = {
     currentScore?: number;
     checks?: CheckType[];
@@ -55,6 +91,10 @@ export declare type StandardType = {
     score?: number;
     total?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type AccountType = {
     failed?: number;
     name?: string;
@@ -64,23 +104,43 @@ export declare type AccountType = {
     standards?: StandardType[];
     total?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type ScoreResultType = {
     account?: AccountType;
     registration?: RegistrationType;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type NameCountByDateAggType = {
     count?: number;
     date?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type SeverityAggType = {
     data?: NameCountByDateAggType[];
     last?: NameCountByDateAggType;
     name?: string;
     progression?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type SeveritiesAggType = {
     severities?: SeverityAggType[];
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type CheckCountByDateAggType = {
     count?: number;
     accounts?: number;
@@ -88,6 +148,10 @@ export declare type CheckCountByDateAggType = {
     partners?: number;
     date?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type CheckAggType = {
     data?: CheckCountByDateAggType[];
     last?: CheckCountByDateAggType;
@@ -96,9 +160,17 @@ export declare type CheckAggType = {
     reference?: string;
     vendorCode?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type ChecksAggType = {
     checks: CheckAggType[];
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type EndCustomerByDateAggType = {
     accounts?: number;
     avgCurrentScore?: number;
@@ -109,6 +181,10 @@ export declare type EndCustomerByDateAggType = {
     total?: number;
     subscriptionReferences?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type EndCustomerAggType = {
     data?: EndCustomerByDateAggType[];
     last?: EndCustomerByDateAggType;
@@ -116,33 +192,61 @@ export declare type EndCustomerAggType = {
     progression?: number;
     reference?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type UnregisteredOfferIaasSubscriptionType = {
     partnerRef?: string;
     friendlyName?: string;
     vendorSubscriptionId?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type UnregisteredOfferIaasType = {
     sku?: string;
     name?: string;
     subscriptions?: UnregisteredOfferIaasSubscriptionType[];
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type UnregisteredOfferSaasType = {
     name?: string;
     subscription?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type UnregisteredOffersType = {
     iaas?: UnregisteredOfferIaasType[];
     saas?: UnregisteredOfferSaasType[];
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type UnregisteredEndCustomerAggType = {
     name?: string;
     reference?: string;
     offers?: UnregisteredOffersType;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type EndCustomersAggType = {
     customers?: EndCustomerAggType[];
     unregisteredCustomers?: UnregisteredEndCustomerAggType[];
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type PartnerByDateAggType = {
     avgCurrentScore?: number;
     date?: string;
@@ -151,6 +255,10 @@ export declare type PartnerByDateAggType = {
     passed?: number;
     total?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type PartnerAggType = {
     data?: PartnerByDateAggType[];
     last?: PartnerByDateAggType;
@@ -158,18 +266,34 @@ export declare type PartnerAggType = {
     progression?: number;
     reference?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type PartnersAggType = {
     partners?: PartnerAggType[];
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type ScoreByMonthAggType = {
     avgCurrentScore?: number;
     date?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type MonthlyTrendAggType = {
     avgCurrentScore?: number;
     period?: PeriodsType;
     scores?: ScoreByMonthAggType[];
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type ScoreByDateAggType = {
     avgCurrentScore?: number;
     date?: string;
@@ -177,10 +301,18 @@ export declare type ScoreByDateAggType = {
     passed?: number;
     total?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type ScoresAggType = {
     last?: ScoreByDateAggType;
     scores?: ScoreByDateAggType[];
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type AccountByDateAggType = {
     avgCurrentScore?: number;
     date?: string;
@@ -189,6 +321,10 @@ export declare type AccountByDateAggType = {
     passed?: number;
     total?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type AccountAggType = {
     data?: AccountByDateAggType[];
     last?: AccountByDateAggType;
@@ -196,10 +332,18 @@ export declare type AccountAggType = {
     progression?: number;
     reference?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type AccountsAggType = {
     accounts?: AccountAggType[];
     unregisteredAccounts?: UnregisteredOffersType;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type StandardByDateAggType = {
     date?: string;
     score?: number;
@@ -207,6 +351,10 @@ export declare type StandardByDateAggType = {
     passed?: number;
     total?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type StandardAggType = {
     data?: StandardByDateAggType[];
     last?: StandardByDateAggType;
@@ -214,9 +362,17 @@ export declare type StandardAggType = {
     progression?: number;
     reference?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type StandardsAggType = {
     standards: StandardAggType[];
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type MarketplacePartnerAggByDateAggType = {
     avgCurrentScore?: number;
     date?: string;
@@ -224,10 +380,18 @@ export declare type MarketplacePartnerAggByDateAggType = {
     passed?: number;
     total?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type MarketplaceByDateAggType = {
     avgCurrentScore?: number;
     date?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type MarketplacePartnerAggType = {
     data?: MarketplacePartnerAggByDateAggType[];
     last?: MarketplacePartnerAggByDateAggType;
@@ -235,6 +399,10 @@ export declare type MarketplacePartnerAggType = {
     reference?: string;
     progression?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type MarketplaceAggType = {
     data?: MarketplaceByDateAggType[];
     last?: MarketplaceByDateAggType;
@@ -242,9 +410,17 @@ export declare type MarketplaceAggType = {
     partners?: MarketplacePartnerAggType[];
     progression?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type MarketplacesAggType = {
     marketplaces: MarketplaceAggType[];
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type CheckByDateType = {
     date?: string;
     flagged?: number;
@@ -253,6 +429,10 @@ export declare type CheckByDateType = {
     processed?: number;
     score?: number;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type ChecksByStandardType = {
     data?: CheckByDateType[];
     description?: string;
@@ -262,11 +442,19 @@ export declare type ChecksByStandardType = {
     reference?: string;
     severity?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type StandardWithCheckType = {
     checks?: ChecksByStandardType[];
     name?: string;
     reference?: string;
 };
+/**
+ * @deprecated
+ * Prefer using equivalent type in the wellArchitected
+ */
 export declare type PeriodsType = {
     from?: string;
     to?: string;

package/package.json

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