@arrowsphere/api-client 3.52.0 → 3.53.0

package/build/wellArchitected/types/wellArchitectedGraphQLSchemas.d.ts

@@ -0,0 +1,125 @@
+import { Merge, Schema } from 'type-fest';
+import { AccountType, CheckType, FilterValuesType, MonthlyTrendAggType, WellArchitectedPeriodType, RegistrationType, StandardAggType, StandardType, EndCustomerByDateAggType, AccountByDateAggType, CheckAggType, WellArchitectedPaginationType, ScoreByDateAggType, StandardWithCheckType, ChecksByStandardType, CheckByDateType, EndCustomerAggType, SeverityAggType, AccountAggType, StandardByDateAggType, ScoresAggType, ScoreByMonthAggType, ScoreByMonthSeverityType, SeverityByDateAggType, MarketplaceAggType, MarketplaceByDateAggType, MarketplacePartnerAggType, MarketplacePartnerAggByDateAggType, CheckCountByDateAggType, PartnerByDateAggType, PartnerAggType, UnregisteredOfferIaasSubscriptionType, UnregisteredOfferIaasType, UnregisteredOfferSaasType, UnregisteredEndCustomerAggType } from './wellArchitectedGraphQLTypes';
+declare type MissingFieldsOfScoreByMonthAggSchema = {
+    severities: Schema<ScoreByMonthSeverityType, boolean>;
+};
+declare type ScoreByMonthAggTypeSchema = Merge<Schema<ScoreByMonthAggType, boolean>, MissingFieldsOfScoreByMonthAggSchema>;
+declare type MissingFieldsOfMonthlyTrendAggSchema = {
+    scores?: ScoreByMonthAggTypeSchema;
+};
+export declare type MonthlyTrendAggSchema = Merge<Schema<MonthlyTrendAggType, boolean>, MissingFieldsOfMonthlyTrendAggSchema>;
+export declare type PaginationSchema = Schema<WellArchitectedPaginationType, boolean>;
+declare type EndCustomerByDateAggSchema = Schema<EndCustomerByDateAggType, boolean>;
+declare type MissingFieldsInEndCustomerAggSchema = {
+    data?: EndCustomerByDateAggSchema;
+};
+declare type EndCustomerAggSchema = Merge<Schema<EndCustomerAggType, boolean>, MissingFieldsInEndCustomerAggSchema>;
+declare type UnregisteredOfferIaasSubscriptionSchema = Schema<UnregisteredOfferIaasSubscriptionType, boolean>;
+declare type MissingFieldsInUnregisteredOfferIaasSchema = {
+    subscriptions?: UnregisteredOfferIaasSubscriptionSchema;
+};
+declare type UnregisteredOfferIaasSchema = Merge<Schema<UnregisteredOfferIaasType, boolean>, MissingFieldsInUnregisteredOfferIaasSchema>;
+declare type UnregisteredOfferSaasSchema = Schema<UnregisteredOfferSaasType, boolean>;
+declare type UnregisteredOffersSchema = {
+    iaas?: UnregisteredOfferIaasSchema;
+    saas?: UnregisteredOfferSaasSchema;
+};
+declare type UnregisteredEndCustomerAggTypeSchema = Schema<UnregisteredEndCustomerAggType, boolean>;
+declare type MissingFieldsInUnregisteredEndCustomerAggSchema = {
+    offers?: UnregisteredOffersSchema;
+};
+declare type UnregisteredEndCustomerAggSchema = Merge<UnregisteredEndCustomerAggTypeSchema, MissingFieldsInUnregisteredEndCustomerAggSchema>;
+export declare type EndCustomersAggSchema = {
+    customers?: EndCustomerAggSchema;
+    unregisteredCustomers?: UnregisteredEndCustomerAggSchema;
+};
+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;
+    unregisteredAccounts?: UnregisteredOffersSchema;
+};
+declare type FilterValuesSchema = Schema<FilterValuesType, boolean>;
+export declare type FilterSchema = {
+    name?: boolean;
+    values?: FilterValuesSchema;
+};
+declare type CheckCountByDateAggSchema = Schema<CheckCountByDateAggType, boolean>;
+declare type MissingFieldsInCheckAggSchema = {
+    data?: CheckCountByDateAggSchema;
+};
+declare type CheckAggSchema = Merge<Schema<CheckAggType, boolean>, MissingFieldsInCheckAggSchema>;
+export declare type ChecksAggSchema = {
+    checks?: CheckAggSchema;
+};
+export declare type PeriodsSchema = Schema<WellArchitectedPeriodType, 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;
+};
+declare type SeverityByDateAggSchema = Schema<SeverityByDateAggType, boolean>;
+declare type MissingFieldsInSeverityAggSchema = {
+    data?: SeverityByDateAggSchema;
+};
+export declare type SeverityAggSchema = Merge<Schema<SeverityAggType, boolean>, MissingFieldsInSeverityAggSchema>;
+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>;
+declare type MarketplacePartnerAggByDateAggSchema = Schema<MarketplacePartnerAggByDateAggType, boolean>;
+declare type MissingFieldsInMarketplacePartnerAggSchema = {
+    data?: MarketplacePartnerAggByDateAggSchema;
+};
+declare type MarketplacePartnerAggSchema = Merge<Schema<MarketplacePartnerAggType, boolean>, MissingFieldsInMarketplacePartnerAggSchema>;
+declare type MarketplaceByDateAggSchema = Schema<MarketplaceByDateAggType, boolean>;
+declare type MissingFieldsInMarketplaceAggSchema = {
+    data?: MarketplaceByDateAggSchema;
+    partners?: MarketplacePartnerAggSchema;
+};
+declare type MarketplaceAggSchema = Merge<Schema<MarketplaceAggType, boolean>, MissingFieldsInMarketplaceAggSchema>;
+export declare type MarketplacesAggSchema = {
+    marketplaces?: MarketplaceAggSchema;
+};
+declare type PartnerByDateAggTypeSchema = Schema<PartnerByDateAggType, boolean>;
+declare type MissingFieldsInPartnerAggSchema = {
+    data?: PartnerByDateAggTypeSchema;
+};
+declare type PartnerAggSchema = Merge<Schema<PartnerAggType, boolean>, MissingFieldsInPartnerAggSchema>;
+export declare type PartnersAggSchema = {
+    partners?: PartnerAggSchema;
+};
+export {};

package/build/wellArchitected/types/wellArchitectedGraphQLSchemas.js

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

package/build/wellArchitected/types/wellArchitectedGraphQLTypes.d.ts

@@ -0,0 +1,339 @@
+/**
+ * Filter Types
+ */
+export declare type FilterType = {
+    name?: string;
+    values?: FilterValuesType[];
+};
+export declare type FilterValuesType = {
+    count?: number;
+    value?: string;
+};
+export declare type WellArchitectedPaginationType = {
+    currentPage?: number;
+    next?: string;
+    perPage?: number;
+    previous?: string;
+    total?: number;
+    totalPage?: number;
+};
+/**
+ * ElasticSearch Types
+ */
+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;
+    group?: string;
+    isFailed?: boolean;
+    name?: string;
+    processed?: number;
+    reference?: string;
+    score?: number;
+    severity?: string;
+};
+export declare type StandardType = {
+    currentScore?: number;
+    checks?: CheckType[];
+    failed?: number;
+    maxScore?: 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;
+};
+/**
+ * Generic Types
+ */
+export declare type WellArchitectedPeriodType = {
+    from?: string;
+    to?: string;
+};
+/**
+ * Severity Aggregation Types
+ */
+export declare type SeverityByDateAggType = {
+    date: string;
+    value: number;
+};
+export declare type SeverityAggType = {
+    data: SeverityByDateAggType[];
+    last: SeverityByDateAggType;
+    name: string;
+    progression: number;
+};
+export declare type SeveritiesAggType = {
+    severities: SeverityAggType[];
+};
+/**
+ * Check Aggregation Types
+ */
+export declare type CheckCountByDateAggType = {
+    accounts?: number;
+    count?: number;
+    customers?: number;
+    date?: string;
+    partners?: number;
+};
+export declare type CheckAggType = {
+    data?: CheckCountByDateAggType[];
+    last?: CheckCountByDateAggType;
+    name?: string;
+    progression?: number;
+    reference?: string;
+    vendorCode?: string;
+};
+export declare type ChecksAggType = {
+    checks: CheckAggType[];
+};
+/**
+ * Subscription Aggregation Types
+ */
+export declare type SubscriptionAggType = {
+    reference: string;
+    updatedAt: string;
+};
+export declare type SubscriptionsAggType = {
+    count: number;
+    subscriptions: SubscriptionAggType[];
+};
+/**
+ * EndCustomer Aggregation Types
+ */
+export declare type EndCustomerByDateAggType = {
+    accounts?: number;
+    date?: string;
+    failed?: number;
+    name?: string;
+    passed?: number;
+    score?: number;
+    scoreUnit?: string;
+    subscriptionReferences?: number;
+    total?: number;
+};
+export declare type EndCustomerAggType = {
+    data?: EndCustomerByDateAggType[];
+    last?: EndCustomerByDateAggType;
+    name?: string;
+    progression?: number;
+    reference?: string;
+};
+export declare type UnregisteredOfferIaasSubscriptionType = {
+    partnerRef?: string;
+    friendlyName?: string;
+    vendorSubscriptionId?: string;
+};
+export declare type UnregisteredOfferIaasType = {
+    sku?: string;
+    name?: string;
+    subscriptions?: UnregisteredOfferIaasSubscriptionType[];
+};
+export declare type UnregisteredOfferSaasType = {
+    name?: string;
+    subscription?: string;
+};
+export declare type UnregisteredOffersType = {
+    iaas?: UnregisteredOfferIaasType[];
+    saas?: UnregisteredOfferSaasType[];
+};
+export declare type UnregisteredEndCustomerAggType = {
+    name?: string;
+    reference?: string;
+    offers?: UnregisteredOffersType;
+};
+export declare type EndCustomersAggType = {
+    customers?: EndCustomerAggType[];
+    unregisteredCustomers?: UnregisteredEndCustomerAggType[];
+};
+/**
+ * Partners Aggregation Types
+ */
+export declare type PartnerByDateAggType = {
+    date?: string;
+    failed?: number;
+    name?: string;
+    passed?: number;
+    score?: number;
+    scoreUnit?: string;
+    total?: number;
+};
+export declare type PartnerAggType = {
+    data?: PartnerByDateAggType[];
+    last?: PartnerByDateAggType;
+    name?: string;
+    progression?: number;
+    reference?: string;
+};
+export declare type PartnersAggType = {
+    partners?: PartnerAggType[];
+};
+/**
+ * Monthly Aggregation Types
+ */
+export declare type ScoreByMonthSeverityType = {
+    name: string;
+    value: number;
+};
+export declare type ScoreByMonthAggType = {
+    date: string;
+    score?: number;
+    scoreUnit?: string;
+    severities?: ScoreByMonthSeverityType[];
+};
+export declare type MonthlyTrendAggType = {
+    period?: WellArchitectedPeriodType;
+    score?: number;
+    scores?: ScoreByMonthAggType[];
+    scoreUnit?: string;
+};
+/**
+ * Score Aggregation Types
+ */
+export declare type ScoreByDateAggType = {
+    date?: string;
+    failed?: number;
+    passed?: number;
+    score?: number;
+    scoreUnit?: string;
+    total?: number;
+};
+export declare type ScoresAggType = {
+    last?: ScoreByDateAggType;
+    progression?: number;
+    scores?: ScoreByDateAggType[];
+};
+/**
+ * Account Aggregation Types
+ */
+export declare type AccountByDateAggType = {
+    date?: string;
+    failed?: number;
+    name?: string;
+    passed?: number;
+    score?: number;
+    scoreUnit?: string;
+    total?: number;
+};
+export declare type AccountAggType = {
+    data?: AccountByDateAggType[];
+    last?: AccountByDateAggType;
+    name?: string;
+    progression?: number;
+    reference?: string;
+};
+export declare type AccountsAggType = {
+    accounts?: AccountAggType[];
+    unregisteredAccounts?: UnregisteredOffersType;
+};
+/**
+ * Standard Aggregation Types
+ */
+export declare type StandardByDateAggType = {
+    date?: string;
+    failed?: number;
+    passed?: number;
+    score?: number;
+    scoreUnit?: string;
+    total?: number;
+};
+export declare type StandardAggType = {
+    data?: StandardByDateAggType[];
+    last?: StandardByDateAggType;
+    name?: string;
+    progression?: number;
+    reference?: string;
+};
+export declare type StandardsAggType = {
+    standards: StandardAggType[];
+};
+/**
+ * Marketplace Aggregation Types
+ */
+export declare type MarketplacePartnerAggByDateAggType = {
+    date?: string;
+    failed?: number;
+    passed?: number;
+    score?: number;
+    scoreUnit?: string;
+    total?: number;
+};
+export declare type MarketplaceByDateAggType = {
+    date?: string;
+    score?: number;
+    scoreUnit?: string;
+};
+export declare type MarketplacePartnerAggType = {
+    data?: MarketplacePartnerAggByDateAggType[];
+    last?: MarketplacePartnerAggByDateAggType;
+    name?: string;
+    reference?: string;
+    progression?: number;
+};
+export declare type MarketplaceAggType = {
+    data?: MarketplaceByDateAggType[];
+    last?: MarketplaceByDateAggType;
+    name?: string;
+    partners?: MarketplacePartnerAggType[];
+    progression?: number;
+};
+export declare type MarketplacesAggType = {
+    marketplaces: MarketplaceAggType[];
+};
+/**
+ * Standard with Check Types
+ */
+export declare type CheckByDateType = {
+    date?: string;
+    flagged?: number;
+    isFailed?: boolean;
+    name?: string;
+    processed?: number;
+    score?: number;
+    scoreUnit?: string;
+};
+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;
+};

package/build/wellArchitected/types/wellArchitectedGraphQLTypes.js

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

package/build/wellArchitected/wellArchitectedGraphQLClient.d.ts

@@ -0,0 +1,21 @@
+import { AbstractGraphQLClient } from '../abstractGraphQLClient';
+import { GetPartnerDataType } from './entities/getPartnerData';
+import { GetCustomerDataType } from './entities/getCustomerData';
+import { GetCustomerAccountDataType } from './entities/getCustomerAccountData';
+import { GetPartnerDataQuery, GetCustomerDataQuery, GetCustomerAccountDataQuery, GetAdminDataQuery } from './types/wellArchitectedGraphQLQueries';
+import { GetAdminDataType } from './entities/getAdminData';
+export declare class WellArchitectedGraphQLClient 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>;
+    getAdminData(getAdminDataQuery: GetAdminDataQuery): Promise<GetAdminDataType | null>;
+    getCustomerData(getCustomerDataQuery: GetCustomerDataQuery): Promise<GetCustomerDataType | null>;
+    getCustomerAccountData(getCustomerAccountDataQuery: GetCustomerAccountDataQuery): Promise<GetCustomerAccountDataType | null>;
+}

package/build/wellArchitected/wellArchitectedGraphQLClient.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WellArchitectedGraphQLClient = 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");
+const getAdminData_1 = require("./entities/getAdminData");
+class WellArchitectedGraphQLClient extends abstractGraphQLClient_1.AbstractGraphQLClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the API
+         */
+        this.basePath = '/wellArchitected';
+        /**
+         * 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) {
+            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.WellArchitectedQueries.GET_PARTNER_DATA]).toJSON();
+        }
+        return null;
+    }
+    async getAdminData(getAdminDataQuery) {
+        const queryStr = this.stringifyQuery(getAdminDataQuery);
+        const getAdminDataResult = await this.find(queryStr);
+        if (getAdminDataResult) {
+            return new getAdminData_1.GetAdminData(getAdminDataResult[queryArguments_1.WellArchitectedQueries.GET_ADMIN_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.WellArchitectedQueries.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.WellArchitectedQueries.GET_CUSTOMER_ACCOUNT_DATA]).toJSON();
+        }
+        return null;
+    }
+}
+exports.WellArchitectedGraphQLClient = WellArchitectedGraphQLClient;
+//# sourceMappingURL=wellArchitectedGraphQLClient.js.map

package/package.json

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