@arrowsphere/api-client 3.52.1-rc.bdj.1 → 3.53.1

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

@@ -0,0 +1,109 @@
+/**
+ * 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 WellArchitectedQueries {
+    GET_ADMIN_DATA = "getAdminData",
+    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.EXCLUSION_FILTERS]?: SearchFilterArgument[];
+    [SearchBodyFields.FILTERS]?: SearchFilterArgument[];
+    [SearchBodyFields.MARKETPLACE]?: string[][];
+    [SearchBodyFields.MONTHLY_TREND_PERIOD]?: PeriodInputArgument;
+    [SearchBodyFields.PERIOD]?: PeriodInputArgument;
+    [SearchBodyFields.SORT]?: SortArgument[];
+    [SearchBodyFields.SUBSCRIPTION_REFERENCE]?: string[][];
+};
+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/wellArchitected/types/queryArguments.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WellArchitectedQueries = 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 WellArchitectedQueries;
+(function (WellArchitectedQueries) {
+    WellArchitectedQueries["GET_ADMIN_DATA"] = "getAdminData";
+    WellArchitectedQueries["GET_PARTNER_DATA"] = "getPartnerData";
+    WellArchitectedQueries["GET_CUSTOMER_DATA"] = "getCustomerData";
+    WellArchitectedQueries["GET_CUSTOMER_ACCOUNT_DATA"] = "getCustomerAccountData";
+})(WellArchitectedQueries = exports.WellArchitectedQueries || (exports.WellArchitectedQueries = {}));
+//# sourceMappingURL=queryArguments.js.map

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

@@ -0,0 +1,75 @@
+import { SearchBodyArgument, PaginateArgument, WellArchitectedQueries } from './queryArguments';
+import { AccountsAggSchema, ChecksAggSchema, EndCustomersAggSchema, MonthlyTrendAggSchema, PaginationSchema, PeriodsSchema, ScoreResultSchema, ScoresAggSchema, SeveritiesAggSchema, StandardsAggSchema, StandardWithCheckSchema, MarketplacesAggSchema, PartnersAggSchema } from './wellArchitectedGraphQLSchemas';
+import { GetPartnerDataFields } from '../entities/getPartnerData';
+import { GetCustomerDataFields } from '../entities/getCustomerData';
+import { GetCustomerAccountDataFields } from '../entities/getCustomerAccountData';
+import { GetAdminDataFields } from '../entities/getAdminData';
+export declare type GetPartnerDataQuery = {
+    [WellArchitectedQueries.GET_PARTNER_DATA]: {
+        __args?: {
+            searchBody?: SearchBodyArgument;
+            paginate?: PaginateArgument;
+        };
+        [GetPartnerDataFields.COLUMN_CHECKS_AGG]?: ChecksAggSchema;
+        [GetPartnerDataFields.COLUMN_END_CUSTOMERS_AGG]?: EndCustomersAggSchema;
+        [GetPartnerDataFields.COLUMN_MARKETPLACES_AGG]?: MarketplacesAggSchema;
+        [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 = {
+    [WellArchitectedQueries.GET_CUSTOMER_DATA]: {
+        __args?: {
+            searchBody?: SearchBodyArgument;
+            paginate?: PaginateArgument;
+        };
+        [GetCustomerDataFields.COLUMN_ACCOUNTS_AGG]?: AccountsAggSchema;
+        [GetCustomerDataFields.COLUMN_CHECKS_AGG]?: ChecksAggSchema;
+        [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]?: StandardWithCheckSchema;
+        [GetCustomerDataFields.COLUMN_SUBSCRIPTION_REFERENCES]?: boolean;
+    };
+};
+export declare type GetCustomerAccountDataQuery = {
+    [WellArchitectedQueries.GET_CUSTOMER_ACCOUNT_DATA]: {
+        __args?: {
+            searchBody?: SearchBodyArgument;
+            paginate?: PaginateArgument;
+        };
+        [GetCustomerAccountDataFields.COLUMN_CHECKS_AGG]?: ChecksAggSchema;
+        [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;
+    };
+};
+export declare type GetAdminDataQuery = {
+    [WellArchitectedQueries.GET_ADMIN_DATA]: {
+        __args?: {
+            searchBody?: SearchBodyArgument;
+            paginate?: PaginateArgument;
+        };
+        [GetAdminDataFields.COLUMN_CHECKS_AGG]?: ChecksAggSchema;
+        [GetAdminDataFields.COLUMN_MARKETPLACES_AGG]?: MarketplacesAggSchema;
+        [GetAdminDataFields.COLUMN_MONTHLY_TREND_AGG]?: MonthlyTrendAggSchema;
+        [GetAdminDataFields.COLUMN_PARTNERS_AGG]?: PartnersAggSchema;
+        [GetAdminDataFields.COLUMN_PAGINATION]?: PaginationSchema;
+        [GetAdminDataFields.COLUMN_PERIOD]?: PeriodsSchema;
+        [GetAdminDataFields.COLUMN_RESULTS]?: ScoreResultSchema;
+        [GetAdminDataFields.COLUMN_SCORES_AGG]?: ScoresAggSchema;
+        [GetAdminDataFields.COLUMN_SEVERITIES_AGG]?: SeveritiesAggSchema;
+    };
+};

package/build/wellArchitected/types/wellArchitectedGraphQLQueries.js

@@ -0,0 +1,8 @@
+"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");
+const getAdminData_1 = require("../entities/getAdminData");
+//# sourceMappingURL=wellArchitectedGraphQLQueries.js.map

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