@spottoai/types-package 1.0.2-beta.43 → 1.0.2-beta.430

package/dist/esm/azure/reportSavingsContributionValidation.js

@@ -0,0 +1,30 @@
+import { isRecord } from './reportEvidenceValidationHelpers.js';
+const isMoneyRange = (value) => {
+    if (!isRecord(value) || typeof value.currency !== 'string' || !/^[A-Z]{3}$/.test(value.currency))
+        return false;
+    const fields = ['minorUnitScale', 'currentMonthlyMinorUnits', 'minSavingsMinorUnits', 'maxSavingsMinorUnits'];
+    if (!fields.every(key => Number.isSafeInteger(value[key]) && Number(value[key]) >= 0))
+        return false;
+    return (Number(value.minorUnitScale) <= 6 &&
+        Number(value.minSavingsMinorUnits) <= Number(value.maxSavingsMinorUnits) &&
+        Number(value.maxSavingsMinorUnits) <= Number(value.currentMonthlyMinorUnits));
+};
+export const isReportPortfolioSavingsContribution = (value) => isRecord(value) &&
+    value.semantics === 'portfolio-contribution' &&
+    isMoneyRange(value.range) &&
+    Array.isArray(value.allocationIds) &&
+    value.allocationIds.length <= 10000 &&
+    value.allocationIds.every(id => typeof id === 'string' && id.trim().length > 0 && id.length <= 16384) &&
+    new Set(value.allocationIds).size === value.allocationIds.length &&
+    (value.allocationIds.length > 0 || value.range.maxSavingsMinorUnits === 0);
+export const isReportScenarioSavings = (value) => isRecord(value) &&
+    value.semantics === 'standalone-scenario' &&
+    isMoneyRange(value.range) &&
+    (value.combinationPolicy === 'additive' || value.combinationPolicy === 'exclusive' || value.combinationPolicy === 'conditional') &&
+    (value.combinationGroupId === undefined || (typeof value.combinationGroupId === 'string' && value.combinationGroupId.length <= 16384));
+export const hasValidReportSavingsMetadata = (value) => ['savingsOwnerResourceId', 'billableComponentKey'].every(key => value[key] === undefined || (typeof value[key] === 'string' && value[key].trim().length > 0 && value[key].length <= 16384)) &&
+    (value.savingsAggregationPolicy === undefined ||
+        value.savingsAggregationPolicy === 'owner-component' ||
+        value.savingsAggregationPolicy === 'resource') &&
+    (value.portfolioContribution === undefined || isReportPortfolioSavingsContribution(value.portfolioContribution)) &&
+    (value.scenarioSavings === undefined || isReportScenarioSavings(value.scenarioSavings));

package/dist/esm/azure/reportSpend.js

@@ -0,0 +1 @@
+export const REPORT_SPEND_LIMITS = { periods: 14, servicesPerPeriod: 100, periodDays: 92, assumptions: 10, textLength: 500 };

package/dist/esm/azure/reportSpendValidation.js

@@ -0,0 +1,189 @@
+import { isPublicCostComposition } from './costComposition.js';
+import { isBoundedRows, isRecord } from './reportEvidenceValidationHelpers.js';
+import { REPORT_SPEND_LIMITS, } from './reportSpend.js';
+import { isReportCalendarDate, isReportCurrency, isReportText, isReportUtcTimestamp, reportMoneyUnits } from './reportSpendValidationHelpers.js';
+const bases = ['billed', 'amortized'];
+const coverageStates = new Set(['complete', 'partial', 'unavailable']);
+const exactFields = (value, required, optional = []) => required.every(key => Object.prototype.hasOwnProperty.call(value, key)) &&
+    Object.keys(value).every(key => [...required, ...optional].includes(key));
+export const isReportSavingsBasis = (value) => typeof value === 'string' && ['billed', 'amortized', 'retail', 'mixed', 'unknown'].includes(value);
+const amountOf = (value) => value.status === 'available' ? reportMoneyUnits(value.component.amount) : undefined;
+function isBasisConsistent(basis, coverage, lens) {
+    if (!isRecord(coverage) || !exactFields(coverage, ['actual', 'estimated', 'combined']))
+        return false;
+    const components = { actual: basis.actual.availability, estimated: basis.estimated.availability, combined: basis.combined };
+    for (const key of ['actual', 'estimated', 'combined']) {
+        if (!coverageStates.has(coverage[key]))
+            return false;
+        const available = components[key].status === 'available';
+        if (available !== (coverage[key] !== 'unavailable'))
+            return false;
+        if (available && amountOf(components[key]) === undefined)
+            return false;
+        if (key !== 'combined' && available && basis[key].support !== 'supported')
+            return false;
+    }
+    const actual = amountOf(components.actual);
+    const estimated = amountOf(components.estimated);
+    const expectedStatus = actual !== undefined
+        ? estimated !== undefined
+            ? 'actual-plus-estimated'
+            : 'actual-only'
+        : estimated !== undefined
+            ? 'estimated-only'
+            : 'unavailable';
+    if (basis.status !== expectedStatus)
+        return false;
+    const combined = amountOf(basis.combined);
+    // Reconciliation may withhold the combined amount even when individual components are available.
+    if (combined === undefined)
+        return true;
+    if (lens === 'actual-only')
+        return actual === combined && coverage.combined === coverage.actual;
+    if (lens === 'estimates-only')
+        return estimated === combined && coverage.combined === coverage.estimated;
+    if (actual === undefined && estimated === undefined)
+        return false;
+    if (combined !== (actual ?? 0n) + (estimated ?? 0n))
+        return false;
+    // A single partial component cannot become a complete combined total. Two components require producer coverage proof.
+    if (actual === undefined)
+        return coverage.combined === coverage.estimated;
+    if (estimated === undefined)
+        return coverage.combined === coverage.actual;
+    return true;
+}
+export function isReportSpendAmounts(value, currency, generatedAt) {
+    if (!isRecord(value) || !exactFields(value, ['composition', 'coverage', 'retail'], ['estimates']) || !isPublicCostComposition(value.composition))
+        return false;
+    if (!isRecord(value.coverage) || !exactFields(value.coverage, [...bases]))
+        return false;
+    if (currency !== undefined && !isReportCurrency(currency))
+        return false;
+    if (generatedAt !== undefined && !isReportUtcTimestamp(generatedAt))
+        return false;
+    if (value.estimates !== undefined && (!isRecord(value.estimates) || !exactFields(value.estimates, [], [...bases])))
+        return false;
+    const currencies = new Set();
+    if (currency)
+        currencies.add(currency);
+    for (const key of bases) {
+        const basis = value.composition[key];
+        if (!isBasisConsistent(basis, value.coverage[key], value.composition.selectedLens))
+            return false;
+        for (const item of [basis.actual.availability, basis.estimated.availability, basis.combined]) {
+            if (item.status === 'available') {
+                if (!isReportCurrency(item.component.currencyCode))
+                    return false;
+                currencies.add(item.component.currencyCode);
+            }
+        }
+        const estimate = isRecord(value.estimates) ? value.estimates[key] : undefined;
+        if (basis.estimated.availability.status === 'available') {
+            if (!isRecord(estimate) ||
+                !exactFields(estimate, ['reason', 'method', 'observedAt']) ||
+                !['billing-lag', 'billing-unavailable-sponsorship', 'other'].includes(estimate.reason) ||
+                !isReportText(estimate.method) ||
+                !isReportUtcTimestamp(estimate.observedAt) ||
+                (generatedAt !== undefined && Date.parse(estimate.observedAt) > Date.parse(generatedAt)))
+                return false;
+        }
+        else if (estimate !== undefined)
+            return false;
+    }
+    const retail = value.retail;
+    if (!isRecord(retail))
+        return false;
+    if (retail.status === 'unavailable') {
+        if (!exactFields(retail, ['status']))
+            return false;
+    }
+    else {
+        if (retail.status !== 'available' ||
+            !exactFields(retail, ['status', 'component', 'coverage', 'scopeDescription', 'pricingSource', 'pricedAt', 'assumptions']) ||
+            !isRecord(retail.component) ||
+            !exactFields(retail.component, ['amount', 'currencyCode']) ||
+            !isReportCurrency(retail.component.currencyCode) ||
+            !['complete', 'partial'].includes(retail.coverage) ||
+            !isReportText(retail.scopeDescription) ||
+            !isReportText(retail.pricingSource) ||
+            !isReportUtcTimestamp(retail.pricedAt) ||
+            (generatedAt !== undefined && Date.parse(retail.pricedAt) > Date.parse(generatedAt)) ||
+            !Array.isArray(retail.assumptions) ||
+            retail.assumptions.length > REPORT_SPEND_LIMITS.assumptions ||
+            !retail.assumptions.every(isReportText))
+            return false;
+        const amount = reportMoneyUnits(retail.component.amount);
+        if (amount === undefined || amount < 0n)
+            return false;
+        currencies.add(retail.component.currencyCode);
+    }
+    return currencies.size <= 1;
+}
+export const hasReportSpendValue = (value) => value.retail.status === 'available' ||
+    bases.some(key => value.composition[key].actual.availability.status === 'available' || value.composition[key].estimated.availability.status === 'available');
+/** Dates, population completeness and actual/estimated selection remain independent checks. */
+export const isReportSpendProjection = (value) => {
+    if (!isRecord(value) ||
+        !exactFields(value, ['currency', 'dateBasis', 'generatedAt', 'freshness', 'periods'], ['sourceObservedAt']) ||
+        !isReportCurrency(value.currency) ||
+        value.dateBasis !== 'billing-calendar' ||
+        !isReportUtcTimestamp(value.generatedAt) ||
+        !['current', 'stale', 'unavailable'].includes(value.freshness) ||
+        !Array.isArray(value.periods) ||
+        value.periods.length > REPORT_SPEND_LIMITS.periods)
+        return false;
+    if (value.sourceObservedAt !== undefined &&
+        (!isReportUtcTimestamp(value.sourceObservedAt) || Date.parse(value.sourceObservedAt) > Date.parse(value.generatedAt)))
+        return false;
+    const seen = new Set();
+    let rollingCount = 0;
+    let historicalCount = 0;
+    let available = false;
+    for (const period of value.periods) {
+        if (!isRecord(period) ||
+            !exactFields(period, ['kind', 'startDate', 'endDate', 'amounts'], ['services']) ||
+            !['calendar-month', 'billing-period', 'rolling-30-days'].includes(period.kind) ||
+            !isReportCalendarDate(period.startDate) ||
+            !isReportCalendarDate(period.endDate))
+            return false;
+        const days = (Date.parse(period.endDate) - Date.parse(period.startDate)) / 86400000 + 1;
+        if (days < 1 || days > REPORT_SPEND_LIMITS.periodDays)
+            return false;
+        if (period.kind === 'calendar-month') {
+            const following = new Date(Date.parse(period.endDate) + 86400000).toISOString().slice(0, 10);
+            if (!period.startDate.endsWith('-01') || period.startDate.slice(0, 7) !== period.endDate.slice(0, 7) || !following.endsWith('-01'))
+                return false;
+        }
+        if (period.kind === 'rolling-30-days') {
+            if (days !== 30 || ++rollingCount > 1)
+                return false;
+        }
+        else if (++historicalCount > 13)
+            return false;
+        const key = `${period.kind}:${period.startDate}:${period.endDate}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        if (!isReportSpendAmounts(period.amounts, value.currency, value.generatedAt))
+            return false;
+        available || (available = hasReportSpendValue(period.amounts));
+        if (period.services !== undefined) {
+            const serviceKeys = new Set();
+            if (!isBoundedRows(period.services, REPORT_SPEND_LIMITS.servicesPerPeriod, (row) => {
+                if (!isRecord(row) ||
+                    !exactFields(row, ['serviceKey', 'name', 'amounts']) ||
+                    !isReportText(row.serviceKey) ||
+                    !isReportText(row.name) ||
+                    serviceKeys.has(row.serviceKey) ||
+                    !isReportSpendAmounts(row.amounts, value.currency, value.generatedAt))
+                    return false;
+                serviceKeys.add(row.serviceKey);
+                available || (available = hasReportSpendValue(row.amounts));
+                return true;
+            }))
+                return false;
+        }
+    }
+    return available ? value.sourceObservedAt !== undefined && value.freshness !== 'unavailable' : value.freshness === 'unavailable';
+};

package/dist/esm/azure/reportSpendValidationHelpers.js

@@ -0,0 +1,22 @@
+import { REPORT_SPEND_LIMITS } from './reportSpend.js';
+export const isReportCalendarDate = (value) => {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const time = Date.parse(`${value}T00:00:00.000Z`);
+    return Number.isFinite(time) && new Date(time).toISOString().slice(0, 10) === value;
+};
+export const isReportUtcTimestamp = (value) => typeof value === 'string' &&
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value) &&
+    isReportCalendarDate(value.slice(0, 10)) &&
+    Number.isFinite(Date.parse(value)) &&
+    new Date(value).toISOString() === (value.length === 20 ? value.replace('Z', '.000Z') : value);
+export const isReportCurrency = (value) => typeof value === 'string' && /^[A-Z]{3}$/.test(value);
+export const isReportText = (value) => typeof value === 'string' && value.trim().length > 0 && value.length <= REPORT_SPEND_LIMITS.textLength;
+/** Bounded exact arithmetic avoids binary floating point and pathological decimal-string input. */
+export const reportMoneyUnits = (value) => {
+    if (typeof value !== 'string' || value.length > 25 || !/^-?(?:0|[1-9]\d{0,14})(?:\.\d{1,8})?$/.test(value))
+        return undefined;
+    const [whole, fraction = ''] = value.replace(/^-/, '').split('.');
+    const amount = BigInt(whole) * 100000000n + BigInt(fraction.padEnd(8, '0'));
+    return value.startsWith('-') ? -amount : amount;
+};

package/dist/esm/azure/reportingTemplates.js

@@ -0,0 +1 @@
+export const REPORTING_TEMPLATE_REPORT_TYPES = ['sdm', 'sow', 'review-checklist', 'architecture-assessment'];

package/dist/esm/azure/reports.js

@@ -0,0 +1,12 @@
+/** Specific reason types for cost changes */
+export var ChangeReasonType;
+(function (ChangeReasonType) {
+    ChangeReasonType["NEW_RESOURCE"] = "new_resource";
+    ChangeReasonType["REMOVED_RESOURCE"] = "removed_resource";
+    ChangeReasonType["QUANTITY_INCREASE"] = "quantity_increase";
+    ChangeReasonType["QUANTITY_DECREASE"] = "quantity_decrease";
+    ChangeReasonType["RATE_CHANGE"] = "rate_change";
+    ChangeReasonType["SKU_CHANGE"] = "sku_change";
+    ChangeReasonType["NEW_METER"] = "new_meter";
+    ChangeReasonType["REMOVED_METER"] = "removed_meter";
+})(ChangeReasonType || (ChangeReasonType = {}));

package/dist/esm/azure/resilienceFacts.js

@@ -0,0 +1,16 @@
+/**
+ * Resilience facts: the small per-resource property reads the resilience story needs that no other collection
+ * carries — storage blob-service data-protection settings and lifecycle management, Azure SQL database backup
+ * retention and failover groups. Collected in the reliability component beside the data-protection posture and
+ * published as `azure-portal/subscriptions/{id}/resilience-facts.json`. Consumed by the cloud-engine
+ * `ProtectionProfileBuilder` (`data-protection:<selector>` capability sources) and available to the resilience story page.
+ *
+ * Spec: `Specs/reporting/utilization-stories-types-package.md` (parent: core `specs/reporting/utilization-stories.md`).
+ * Additive: consumers tolerate unknown fields. Field semantics: `undefined` = not read (the request failed, was not
+ * applicable or was skipped) and resolves to an `unknown` capability; `null` = read and absent/disabled. A failed
+ * read must never be presented as "disabled".
+ */
+export const RESILIENCE_FACTS_SCHEMA_VERSION = 1;
+export const RESILIENCE_FACTS_SOURCE = 'AzureResilienceFacts';
+export const RESILIENCE_FACTS_PORTAL_FILE = 'resilience-facts.json';
+export const RESILIENCE_FACTS_RAW_FILE = 'data-protection/resilience-facts.json.gz';

package/dist/esm/azure/resilienceFactsValidation.js

@@ -0,0 +1,64 @@
+import { isCount, isDateTime, isFiniteNumber, isRecord, isString, isStringArray } from '../common/validationHelpers.js';
+import { RESILIENCE_FACTS_SCHEMA_VERSION, RESILIENCE_FACTS_SOURCE, } from './resilienceFacts.js';
+const STATUSES = new Set(['collected', 'partial', 'failed', 'not-applicable']);
+const isNullableBoolean = (value) => value === null || typeof value === 'boolean';
+const isNullableNumber = (value) => value === null || isFiniteNumber(value);
+const isOptionalNullableNumber = (value) => value === undefined || isNullableNumber(value);
+const isOptionalNullableString = (value) => value === undefined || value === null || isString(value);
+const isRetention = (value) => value === undefined || value === null || (isRecord(value) && typeof value.enabled === 'boolean' && isOptionalNullableNumber(value.days));
+const isOptionalNullableBoolean = (value) => value === undefined || isNullableBoolean(value);
+const isStorageFacts = (value) => isRecord(value) &&
+    isRetention(value.blobSoftDelete) &&
+    isRetention(value.containerSoftDelete) &&
+    isOptionalNullableBoolean(value.versioning) &&
+    isRetention(value.changeFeed) &&
+    isRetention(value.pointInTimeRestore) &&
+    isOptionalNullableString(value.kind) &&
+    (value.managementPolicy === undefined ||
+        value.managementPolicy === null ||
+        (isRecord(value.managementPolicy) &&
+            typeof value.managementPolicy.present === 'boolean' &&
+            (value.managementPolicy.ruleCount === undefined || isCount(value.managementPolicy.ruleCount))));
+const isSqlFacts = (value) => isRecord(value) &&
+    isOptionalNullableNumber(value.shortTermRetentionDays) &&
+    isOptionalNullableNumber(value.diffBackupIntervalHours) &&
+    (value.longTermRetention === undefined ||
+        value.longTermRetention === null ||
+        (isRecord(value.longTermRetention) &&
+            typeof value.longTermRetention.enabled === 'boolean' &&
+            isOptionalNullableString(value.longTermRetention.weekly) &&
+            isOptionalNullableString(value.longTermRetention.monthly) &&
+            isOptionalNullableString(value.longTermRetention.yearly) &&
+            isOptionalNullableNumber(value.longTermRetention.weekOfYear))) &&
+    (value.failoverGroup === undefined ||
+        value.failoverGroup === null ||
+        (isRecord(value.failoverGroup) &&
+            isString(value.failoverGroup.id) &&
+            isString(value.failoverGroup.name) &&
+            isStringArray(value.failoverGroup.partnerServers) &&
+            isOptionalNullableString(value.failoverGroup.readWriteFailoverPolicy) &&
+            isOptionalNullableString(value.failoverGroup.role))) &&
+    isOptionalNullableString(value.backupStorageRedundancy);
+export const isResilienceFactsItem = (value) => isRecord(value) &&
+    isString(value.resourceId) &&
+    isString(value.resourceType) &&
+    isString(value.status) &&
+    STATUSES.has(value.status) &&
+    isDateTime(value.observedAt) &&
+    isCount(value.requestCount) &&
+    (value.errors === undefined || isStringArray(value.errors)) &&
+    (value.storage === undefined || isStorageFacts(value.storage)) &&
+    (value.sql === undefined || isSqlFacts(value.sql));
+export const isResilienceFactsProjection = (value) => isRecord(value) &&
+    value.schemaVersion === RESILIENCE_FACTS_SCHEMA_VERSION &&
+    value.source === RESILIENCE_FACTS_SOURCE &&
+    isString(value.subscriptionId) &&
+    (value.tenantId === undefined || isString(value.tenantId)) &&
+    isDateTime(value.generatedAt) &&
+    isRecord(value.summary) &&
+    (value.summary.notApplicable === undefined || isCount(value.summary.notApplicable)) &&
+    ['storageAccounts', 'sqlDatabases', 'sqlServers', 'collected', 'partial', 'failed', 'requestCount'].every(key => isCount(value.summary[key])) &&
+    Array.isArray(value.items) &&
+    value.items.every(isResilienceFactsItem) &&
+    Array.isArray(value.issues) &&
+    value.issues.every(issue => isRecord(issue) && (issue.severity === 'warning' || issue.severity === 'error') && isString(issue.code) && isString(issue.message));

package/dist/esm/azure/resourceHealth.js

@@ -0,0 +1,12 @@
+export const RESOURCE_HEALTH_EVENTS_FILE_NAME = 'microsoft.resourcehealth-events.json';
+export const RESOURCE_HEALTH_EVENTS_IMPACTED_RESOURCES_FILE_NAME = 'microsoft.resourcehealth-events-impactedresources.json';
+export const RESOURCE_HEALTH_AVAILABILITY_STATUSES_FILE_NAME = 'microsoft.resourcehealth-availabilitystatuses.json';
+export const RESOURCE_HEALTH_EVENTS_PORTAL_FILE_NAME = 'health-events.json';
+export const RESOURCE_HEALTH_AVAILABILITY_STATUSES_PORTAL_FILE_NAME = 'health-availability-statuses.json';
+export const RESOURCE_HEALTH_INDEX_FILE_NAME = 'history/resource-health/index.json';
+export const AZURE_RESOURCE_HEALTH_EVENTS_SOURCE = 'Microsoft.ResourceHealth/events';
+export const AZURE_RESOURCE_HEALTH_IMPACTED_RESOURCES_SOURCE = 'Microsoft.ResourceHealth/events/impactedResources';
+export const AZURE_RESOURCE_HEALTH_AVAILABILITY_STATUSES_SOURCE = 'Microsoft.ResourceHealth/availabilityStatuses';
+export const RESOURCE_HEALTH_EVENTS_SOURCE = AZURE_RESOURCE_HEALTH_EVENTS_SOURCE;
+export const RESOURCE_HEALTH_EVENTS_IMPACTED_RESOURCES_SOURCE = AZURE_RESOURCE_HEALTH_IMPACTED_RESOURCES_SOURCE;
+export const RESOURCE_HEALTH_AVAILABILITY_STATUSES_SOURCE = AZURE_RESOURCE_HEALTH_AVAILABILITY_STATUSES_SOURCE;

package/dist/esm/azure/resourceOptimization.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/azure/resources.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/azure/reviewChecklist.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/azure/savings.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/azure/secureScore.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/azure/security.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/azure/serviceRetirement.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/azure/serviceRetirementState.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/azure/serviceRetirementWorkManagement.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/azure/storage-inventory.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/azure/subscriptions.js

@@ -0,0 +1,33 @@
+import { isAzureProviderScopeFinancialChargeSpendBreakdownV1, } from './financialChargePolicy.js';
+const AZURE_NATIVE_STATS_OPTIONAL_MONEY_FIELDS = [
+    'spend30Days',
+    'spend30DaysAmortized',
+    'spendPrevious30Days',
+    'spendPrevious30DaysAmortized',
+    'spend7Days',
+    'spend7DaysAmortized',
+    'spendPrevious7Days',
+    'spendPrevious7DaysAmortized',
+    'spend30DaysBillingBacked',
+    'spend30DaysAmortizedBillingBacked',
+    'spend30DaysEstimated',
+    'spend30DaysAmortizedEstimated',
+];
+const isFinancialStatsRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** Exact top-level validator for the dashboard Azure-native display projection. */
+export const isAzureNativeSubscriptionFinancialStatsV1 = (value) => {
+    if (!isFinancialStatsRecord(value))
+        return false;
+    const required = ['contractVersion', 'policyRef', 'status', 'resourcesByLocation', 'resourcesByType'];
+    const allowed = new Set([...required, 'financialChargeSpend', ...AZURE_NATIVE_STATS_OPTIONAL_MONEY_FIELDS]);
+    if (!required.every(field => Object.prototype.hasOwnProperty.call(value, field)) || !Object.keys(value).every(field => allowed.has(field))) {
+        return false;
+    }
+    return (value.contractVersion === 'azure-native-subscription-financial-stats/v1' &&
+        value.policyRef === 'azure-cloud-services-excluding-marketplace/v1' &&
+        (value.status === 'complete' || value.status === 'partial') &&
+        (value.financialChargeSpend === undefined || isAzureProviderScopeFinancialChargeSpendBreakdownV1(value.financialChargeSpend)) &&
+        Array.isArray(value.resourcesByLocation) &&
+        Array.isArray(value.resourcesByType) &&
+        AZURE_NATIVE_STATS_OPTIONAL_MONEY_FIELDS.every(field => value[field] === undefined || (typeof value[field] === 'number' && Number.isFinite(value[field]))));
+};