@spottoai/types-package 1.0.2-dev1138.13 → 1.0.2-dev1138.14

package/dist/esm/azure/reportEvidenceValidationHelpers.js

@@ -0,0 +1,94 @@
+import { REPORT_EVIDENCE_LIMITS } from './reportEvidence.js';
+import { isBoundedRows, isCount, isCountRecord, isFiniteNumber, isOptionalFiniteNumber, isOptionalString, isRecord, isString, isStringArray, hasOptionalNumbers, hasOptionalStrings, } from '../common/validationHelpers.js';
+export { isRecord, isString, isOptionalString, isFiniteNumber, isOptionalFiniteNumber, isOptionalBoolean, isCount, isDateTime, isStringArray, isCountRecord, countTotal, hasOptionalStrings, hasOptionalNumbers, isBoundedRows, } from '../common/validationHelpers.js';
+export const isProjectionRows = (value, limit = REPORT_EVIDENCE_LIMITS.detailRows) => isBoundedRows(value, limit, isRecord);
+export const hasRequiredRecords = (value, keys) => keys.every(key => isRecord(value[key]));
+export const isSourceFileStatus = (value) => isRecord(value) &&
+    isString(value.path) &&
+    typeof value.available === 'boolean' &&
+    (value.recordCount === undefined || isCount(value.recordCount)) &&
+    isOptionalString(value.note);
+export const isTagCoverage = (value) => isRecord(value) &&
+    isCount(value.withTags) &&
+    isCount(value.withoutTags) &&
+    isFiniteNumber(value.coveragePercentage) &&
+    Array.isArray(value.topTagKeys) &&
+    value.topTagKeys.every(row => isRecord(row) && isString(row.key) && isCount(row.count));
+const isTopSpendResource = (value) => isRecord(value) &&
+    isString(value.id) &&
+    isString(value.name) &&
+    isString(value.type) &&
+    isOptionalString(value.location) &&
+    isFiniteNumber(value.spend30Days) &&
+    isOptionalFiniteNumber(value.spend30DaysAmortized);
+export const isResourceSummary = (value) => isRecord(value) &&
+    isCount(value.total) &&
+    Array.isArray(value.byType) &&
+    value.byType.length <= REPORT_EVIDENCE_LIMITS.summaryDimensions &&
+    value.byType.every(row => isRecord(row) && isString(row.type) && isCount(row.count) && isOptionalFiniteNumber(row.spend30Days)) &&
+    Array.isArray(value.byLocation) &&
+    value.byLocation.length <= REPORT_EVIDENCE_LIMITS.summaryDimensions &&
+    value.byLocation.every(row => isRecord(row) && isString(row.location) && isCount(row.count) && isOptionalFiniteNumber(row.spend30Days)) &&
+    isRecord(value.tagCoverage) &&
+    isTagCoverage(value.tagCoverage) &&
+    Array.isArray(value.tagCoverage.topTagKeys) &&
+    value.tagCoverage.topTagKeys.length <= REPORT_EVIDENCE_LIMITS.summaryRows &&
+    Array.isArray(value.topSpendResources) &&
+    value.topSpendResources.length <= REPORT_EVIDENCE_LIMITS.summaryRows &&
+    value.topSpendResources.every(isTopSpendResource);
+const isReportBudgetProjection = (value) => isRecord(value) &&
+    hasOptionalStrings(value, ['name', 'startDate', 'endDate', 'timeGrain', 'category', 'currencyCode']) &&
+    hasOptionalNumbers(value, ['amount', 'currentSpend', 'forecastedSpend']) &&
+    (value.filter === undefined || isRecord(value.filter));
+export const isCostSummary = (value) => {
+    if (!isRecord(value) || !isRecord(value.sourceMetadata) || !Array.isArray(value.topSpendResources))
+        return false;
+    if (!hasOptionalStrings(value, ['currency', 'currencySymbol']) ||
+        !hasOptionalNumbers(value, ['spend30Days', 'spend30DaysAmortized', 'totalRetailCost', 'miscCost', 'rollingCostRecordCount']) ||
+        (value.budget !== undefined && !isReportBudgetProjection(value.budget)) ||
+        !isString(value.sourceMetadata.spend30DaysSource) ||
+        !isString(value.sourceMetadata.spend30DaysAmortizedSource) ||
+        !isString(value.sourceMetadata.totalRetailCostSource) ||
+        !isString(value.sourceMetadata.rollingCostFile) ||
+        !isOptionalFiniteNumber(value.sourceMetadata.rollingCostRecordCount) ||
+        !value.topSpendResources.every(isTopSpendResource)) {
+        return false;
+    }
+    return (value.period === undefined ||
+        (isRecord(value.period) &&
+            value.period.type === 'rolling_30_days' &&
+            isString(value.period.source) &&
+            hasOptionalStrings(value.period, ['startDate', 'endDate'])));
+};
+export const isRecommendationSummary = (value) => isRecord(value) &&
+    isCount(value.total) &&
+    isCountRecord(value.byPillar) &&
+    isCountRecord(value.byImpact) &&
+    isCountRecord(value.byEffort) &&
+    isStringArray(value.topRecommendationIds) &&
+    value.topRecommendationIds.length <= REPORT_EVIDENCE_LIMITS.topRecommendationIds &&
+    isRecord(value.topRecommendationIdsByPillar) &&
+    Object.values(value.topRecommendationIdsByPillar).every(ids => isStringArray(ids) && ids.length <= REPORT_EVIDENCE_LIMITS.topRecommendationIdsPerPillar);
+export const isRetirementSummary = (value) => isRecord(value) &&
+    isCount(value.total) &&
+    isCount(value.sourceRecordCount) &&
+    isCount(value.excludedUnlinked) &&
+    isCount(value.excludedCommitmentExpiries) &&
+    isCount(value.within180Days) &&
+    isCount(value.expiredOrPastDue) &&
+    Array.isArray(value.upcoming) &&
+    value.upcoming.length <= REPORT_EVIDENCE_LIMITS.upcomingEvents &&
+    value.upcoming.every(row => isRecord(row) && isOptionalString(row.id) && isOptionalString(row.title) && isOptionalString(row.retirementDate) && isCount(row.resourceCount));
+export const isCommitmentExpirySummary = (value) => isRecord(value) &&
+    isCount(value.total) &&
+    isCount(value.sourceRecordCount) &&
+    isCount(value.within180Days) &&
+    isCount(value.expiredOrPastDue) &&
+    Array.isArray(value.upcoming) &&
+    value.upcoming.length <= REPORT_EVIDENCE_LIMITS.upcomingEvents &&
+    value.upcoming.every(row => isRecord(row) && isOptionalString(row.id) && isOptionalString(row.title) && isOptionalString(row.expiryDate) && isCount(row.resourceCount));
+export const isEvidenceReference = (value) => isRecord(value) &&
+    isString(value.source) &&
+    isString(value.summary) &&
+    (value.value === undefined || ['string', 'number', 'boolean'].includes(typeof value.value)) &&
+    (typeof value.value !== 'number' || Number.isFinite(value.value));

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/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/subscriptions.js

@@ -1 +1,33 @@
-export {};
+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]))));
+};

package/dist/esm/azure/views.js

@@ -116,6 +116,12 @@ const isViewArtifactDescriptor = (value, runId, runReference = runId) => isRecor
     isNonNegativeSafeInteger(value.byteLength) &&
     isSha256(value.sha256);
 const isPublishedViewCoverage = (value) => value === 'complete' || value === 'partial';
+const hasValidPublicProjectionContracts = (value) => value === undefined ||
+    (Array.isArray(value) &&
+        value.length > 0 &&
+        value.length <= 32 &&
+        value.every(contract => isStrictNonEmptyString(contract) && contract.length <= 128) &&
+        new Set(value).size === value.length);
 const isProjectedSectionPathForArtifact = (value, artifactPath) => {
     if (!isStrictNonEmptyString(value))
         return false;
@@ -366,7 +372,8 @@ export const isPublishedViewManifestV4 = (value) => {
         !isSha256(value.compositeDependencyDigest) ||
         !isStrictCanonicalIsoTimestamp(value.completedAt) ||
         !isArtifactPublicationDecision(value.publicationDecision) ||
-        !hasPublishedViewDecisionBounds(value.publicationDecision)) {
+        !hasPublishedViewDecisionBounds(value.publicationDecision) ||
+        !hasValidPublicProjectionContracts(value.publicProjectionContracts)) {
         return false;
     }
     return (isPublishedDecisionForCoverage(value.publicationDecision, value.coverage) &&

package/dist/esm/azure/vmPatchManagement.js

@@ -0,0 +1,3 @@
+export const VM_PATCH_MANAGEMENT_SCHEMA_VERSION = 1;
+export const PATCH_MANAGEMENT_PORTAL_FILE_NAME = 'patch-management.json.gz';
+export const AZURE_VM_PATCH_MANAGEMENT_RESOURCE_TYPE = 'microsoft.compute/virtualmachines';

package/dist/esm/common/index.js

@@ -4,6 +4,9 @@ export * from './pagination.js';
 export * from './provider.js';
 export * from './providerSyncProgress.js';
 export * from './relationships.js';
+export * from './resourceGraph.js';
+export * from './resourceGraphValidation.js';
+export * from './resourceIdentity.js';
 export * from './syncProgress.js';
 export * from './sha256.js';
 export * from './exactDecimal.js';

package/dist/esm/common/resourceGraph.js

@@ -0,0 +1,13 @@
+/**
+ * Provider-neutral resource relationship graph published for one provider
+ * account. Families, relationship types, and synthetic types are open
+ * identifiers: a new provider service needs no package change.
+ */
+export const RESOURCE_GRAPH_SCHEMA_VERSION = 1;
+/** Package-owned logical artifact name; storage paths remain producer-owned. */
+export const RESOURCE_GRAPH_LOGICAL_NAME = 'relationships.json.gz';
+export const RESOURCE_GRAPH_NODE_KINDS = ['scope', 'region', 'zone', 'group', 'resource', 'synthetic'];
+export const RESOURCE_GRAPH_NODE_ROLES = ['network-baseline', 'topology', 'workload'];
+export const RESOURCE_GRAPH_EDGE_KINDS = ['contains', 'depends_on'];
+export const RESOURCE_GRAPH_EDGE_CONFIDENCES = ['high', 'medium', 'low'];
+export const RESOURCE_GRAPH_EVIDENCE_METHODS = ['field-derived', 'field-reference', 'persisted-inventory', 'request-scope'];