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

package/dist/esm/aws/portalPublicArtifactCurrentValidation.js

@@ -1,328 +0,0 @@
-import { AWS_PORTAL_ACCOUNT_SUMMARY_LOGICAL_NAME, AWS_PORTAL_RESOURCE_COLLECTION_LOGICAL_NAME, } from './portalPublicArtifacts.js';
-import { asRecord, assertExactKeys, assertPublicJson, assertUnique, assertValue, isoTimestamp, nonNegativeInteger, requiredBoolean, requiredEnum, requiredString, stringArray, validateAccountScope, validateFreshness, validateJsonObject, validatePortalEnvelope, validateResourceScope, } from './portalPublicArtifactValidationCommon.js';
-import { validateAwsPortalBillingBlock, validateAwsPortalRecommendationCoverage } from './portalPublicArtifactEvidenceValidation.js';
-import { validateRecommendationActionability, validateResourceBillingEvidence, validateTemplateProvenanceSources, } from './portalPublicArtifactNestedEvidenceValidation.js';
-const DISCOVERY_FAMILIES = [
-    'ec2-instance',
-    'ebs-volume',
-    'efs-file-system',
-    'lambda-function',
-    'elasticache-cache-cluster',
-    'elasticache-serverless-cache',
-    'vpc',
-    'subnet',
-    'route-table',
-    'internet-gateway',
-    'nat-gateway',
-    'network-interface',
-    'virtual-private-gateway',
-    'load-balancer-v2',
-    'classic-load-balancer',
-    'security-group',
-    'rds-db-cluster',
-    'rds-db-instance',
-];
-const METRIC_FAMILIES = [
-    'ec2-core-utilization',
-    'ebs-volume-performance',
-    'lambda-function-performance',
-    'load-balancer-v2-network-traffic',
-    'load-balancer-v2-application-traffic',
-    'rds-db-instance-utilization',
-];
-const RECOMMENDATION_SOURCES = [
-    'custom',
-    'compute-optimizer',
-    'cost-optimization-hub',
-    'resilience-hub',
-    'security-hub',
-    'trusted-advisor',
-    'well-architected',
-];
-const CURRENT_KEYS = [
-    'schemaVersion',
-    'portalSchemaVersion',
-    'provider',
-    'accountId',
-    'artifactType',
-    'artifactGeneration',
-    'generatedAt',
-    'logicalName',
-    'scope',
-];
-export function validateAwsPortalResourceCollectionDetailArtifact(value) {
-    const artifact = asRecord(value, 'artifact');
-    const { accountId } = validatePortalEnvelope(artifact, 'resource-collection', [...CURRENT_KEYS, 'summary', 'coverage', 'resources']);
-    assertValue(artifact.logicalName, AWS_PORTAL_RESOURCE_COLLECTION_LOGICAL_NAME, 'artifact.logicalName');
-    const scope = validateResourceScope(artifact.scope, accountId, 'artifact.scope');
-    validateResourceSummary(artifact.summary, 'artifact.summary');
-    validateResourceCoverage(artifact.coverage, accountId, scope);
-    if (!Array.isArray(artifact.resources))
-        throw new Error('artifact.resources must be an array.');
-    validateResources(artifact.resources, scope.resourceRegions);
-    const summary = asRecord(artifact.summary, 'artifact.summary');
-    if (summary.returnedResourceCount !== artifact.resources.length)
-        throw new Error('artifact.summary.returnedResourceCount must equal artifact.resources length.');
-    if (Number(summary.totalDiscoveredResourceCount) < Number(summary.returnedResourceCount))
-        throw new Error('artifact.summary.totalDiscoveredResourceCount must not be less than returnedResourceCount.');
-    assertPublicJson(artifact, 'artifact');
-    return value;
-}
-export function validateAwsPortalAccountSummaryDetailArtifact(value) {
-    const artifact = asRecord(value, 'artifact');
-    const { accountId } = validatePortalEnvelope(artifact, 'account-summary', [
-        ...CURRENT_KEYS,
-        'account',
-        'billing',
-        'discovery',
-        'metrics',
-        'recommendations',
-    ]);
-    assertValue(artifact.logicalName, AWS_PORTAL_ACCOUNT_SUMMARY_LOGICAL_NAME, 'artifact.logicalName');
-    const scope = validateAccountScope(artifact.scope, accountId, 'artifact.scope');
-    validateAccount(artifact.account, accountId);
-    validateAwsPortalBillingBlock(artifact.billing, 'artifact.billing', scope.billing, accountId, true);
-    validateDiscovery(artifact.discovery, scope.resourceRegions, 'artifact.discovery');
-    validateMetrics(artifact.metrics, scope.resourceRegions, 'artifact.metrics', 'account');
-    validateAwsPortalRecommendationCoverage(artifact.recommendations, accountId, scope.resourceRegions, 'artifact.recommendations', RECOMMENDATION_SOURCES, true);
-    assertPublicJson(artifact, 'artifact');
-    return value;
-}
-function validateResourceSummary(value, field) {
-    const summary = asRecord(value, field);
-    const keys = [
-        'totalDiscoveredResourceCount',
-        'returnedResourceCount',
-        'emptyCollection',
-        'truncated',
-        'unmatchedRecommendationResourceCount',
-        'unmatchedBillingExpenseCount',
-    ];
-    assertExactKeys(summary, keys, field);
-    keys.filter(key => !['emptyCollection', 'truncated'].includes(key)).forEach(key => nonNegativeInteger(summary[key], `${field}.${key}`));
-    requiredBoolean(summary.emptyCollection, `${field}.emptyCollection`);
-    requiredBoolean(summary.truncated, `${field}.truncated`);
-    if (summary.emptyCollection === true && Number(summary.returnedResourceCount) !== 0)
-        throw new Error(`${field}.emptyCollection requires zero returned resources.`);
-}
-function validateResourceCoverage(value, accountId, scope) {
-    const coverage = asRecord(value, 'artifact.coverage');
-    assertExactKeys(coverage, ['billing', 'discovery', 'metrics', 'recommendations', 'virtualTags'], 'artifact.coverage');
-    validateAwsPortalBillingBlock(coverage.billing, 'artifact.coverage.billing', scope.billing, accountId, false);
-    validateDiscovery(coverage.discovery, scope.resourceRegions, 'artifact.coverage.discovery');
-    validateMetrics(coverage.metrics, scope.resourceRegions, 'artifact.coverage.metrics', 'resource');
-    validateAwsPortalRecommendationCoverage(coverage.recommendations, accountId, scope.resourceRegions, 'artifact.coverage.recommendations', RECOMMENDATION_SOURCES, false);
-    if (coverage.virtualTags !== undefined)
-        validateVirtualTags(coverage.virtualTags);
-}
-function validateDiscovery(value, regions, field) {
-    const discovery = asRecord(value, field);
-    assertExactKeys(discovery, ['families'], field);
-    if (!Array.isArray(discovery.families))
-        throw new Error(`${field}.families must be an array.`);
-    const identities = [];
-    discovery.families.forEach((entry, index) => {
-        const itemField = `${field}.families[${index}]`;
-        const family = asRecord(entry, itemField);
-        assertExactKeys(family, ['family', 'resourceRegion', 'freshness', 'summary', 'groupedTotals'], itemField);
-        const familyName = requiredEnum(family.family, DISCOVERY_FAMILIES, `${itemField}.family`);
-        const region = requiredString(family.resourceRegion, `${itemField}.resourceRegion`);
-        if (!regions.includes(region))
-            throw new Error(`${itemField}.resourceRegion is outside artifact scope.`);
-        identities.push(`${familyName}|${region}`);
-        validateFreshness(family.freshness, `${itemField}.freshness`, 'lastSuccessfulRefreshAt');
-        validateJsonObject(family.summary, `${itemField}.summary`);
-        validateJsonObject(family.groupedTotals, `${itemField}.groupedTotals`);
-    });
-    assertUnique(identities, `${field}.families`);
-}
-function validateMetrics(value, regions, field, kind) {
-    const metrics = asRecord(value, field);
-    assertExactKeys(metrics, ['families'], field);
-    if (!Array.isArray(metrics.families))
-        throw new Error(`${field}.families must be an array.`);
-    const identities = [];
-    metrics.families.forEach((entry, index) => {
-        const itemField = `${field}.families[${index}]`;
-        const family = asRecord(entry, itemField);
-        const keys = kind === 'resource'
-            ? ['metricFamily', 'resourceRegion', 'requestedMonths', 'availableMonths', 'missingMonths', 'coverage', 'summary']
-            : ['metricFamily', 'resourceRegion', 'status', 'requestedMonths', 'availableMonths', 'missingMonths', 'freshness', 'readiness', 'summary'];
-        assertExactKeys(family, keys, itemField);
-        const metricFamily = requiredEnum(family.metricFamily, METRIC_FAMILIES, `${itemField}.metricFamily`);
-        const region = requiredString(family.resourceRegion, `${itemField}.resourceRegion`);
-        if (!regions.includes(region))
-            throw new Error(`${itemField}.resourceRegion is outside artifact scope.`);
-        identities.push(`${metricFamily}|${region}`);
-        if (family.status !== undefined)
-            requiredEnum(family.status, ['available', 'not-found'], `${itemField}.status`);
-        const requestedMonths = stringArray(family.requestedMonths, `${itemField}.requestedMonths`);
-        const availableMonths = stringArray(family.availableMonths, `${itemField}.availableMonths`);
-        const missingMonths = stringArray(family.missingMonths, `${itemField}.missingMonths`);
-        [...requestedMonths, ...availableMonths, ...missingMonths].forEach(month => {
-            if (!/^\d{4}-(0[1-9]|1[0-2])$/.test(month))
-                throw new Error(`${itemField} contains a non-canonical billing month: ${month}.`);
-        });
-        const classifiedMonths = [...availableMonths, ...missingMonths].sort();
-        assertUnique(classifiedMonths, `${itemField} classified months`);
-        if (JSON.stringify(requestedMonths) !== JSON.stringify(classifiedMonths))
-            throw new Error(`${itemField} requestedMonths must equal availableMonths plus missingMonths.`);
-        if (family.freshness !== undefined)
-            validateFreshness(family.freshness, `${itemField}.freshness`, 'lastSuccessfulRefreshAt');
-        if (family.readiness !== undefined)
-            validateJsonObject(family.readiness, `${itemField}.readiness`);
-        if (family.coverage !== undefined)
-            validateJsonObject(family.coverage, `${itemField}.coverage`);
-        if (family.summary !== undefined)
-            validateJsonObject(family.summary, `${itemField}.summary`);
-    });
-    assertUnique(identities, `${field}.families`);
-}
-function validateVirtualTags(value) {
-    const tags = asRecord(value, 'artifact.coverage.virtualTags');
-    assertExactKeys(tags, ['status', 'source', 'generatedAt', 'rulesHash', 'enabledRuleCount', 'appliedRuleCount', 'taggedResourceCount', 'unsupportedRuleCount', 'reason'], 'artifact.coverage.virtualTags');
-    requiredEnum(tags.status, ['available', 'missing', 'malformed', 'unsupported'], 'artifact.coverage.virtualTags.status');
-    assertValue(tags.source, 'spotto-tags', 'artifact.coverage.virtualTags.source');
-    isoTimestamp(tags.generatedAt, 'artifact.coverage.virtualTags.generatedAt');
-    if (tags.rulesHash !== undefined && !/^[a-f0-9]{64}$/.test(String(tags.rulesHash)))
-        throw new Error('artifact.coverage.virtualTags.rulesHash must be a SHA-256.');
-    ['enabledRuleCount', 'appliedRuleCount', 'taggedResourceCount', 'unsupportedRuleCount'].forEach(key => nonNegativeInteger(tags[key], `artifact.coverage.virtualTags.${key}`));
-    if (tags.reason !== undefined)
-        requiredString(tags.reason, 'artifact.coverage.virtualTags.reason');
-}
-function validateResources(value, regions) {
-    if (!Array.isArray(value))
-        throw new Error('artifact.resources must be an array.');
-    const stableKeys = [];
-    value.forEach((entry, index) => {
-        const field = `artifact.resources[${index}]`;
-        const resource = asRecord(entry, field);
-        assertExactKeys(resource, [
-            'stableKey',
-            'family',
-            'resourceRegion',
-            'resourceType',
-            'resourceArn',
-            'resourceId',
-            'resourceName',
-            'tags',
-            'spottoTags',
-            'discovery',
-            'billing',
-            'metrics',
-            'recommendations',
-        ], field);
-        stableKeys.push(requiredString(resource.stableKey, `${field}.stableKey`));
-        requiredEnum(resource.family, DISCOVERY_FAMILIES, `${field}.family`);
-        const region = requiredString(resource.resourceRegion, `${field}.resourceRegion`);
-        if (!regions.includes(region))
-            throw new Error(`${field}.resourceRegion is outside artifact scope.`);
-        requiredString(resource.resourceType, `${field}.resourceType`);
-        ['resourceArn', 'resourceId', 'resourceName'].forEach(key => {
-            if (resource[key] !== undefined)
-                requiredString(resource[key], `${field}.${key}`);
-        });
-        if (resource.tags !== undefined)
-            validateStringMap(resource.tags, `${field}.tags`);
-        if (resource.spottoTags !== undefined)
-            validateJsonObject(resource.spottoTags, `${field}.spottoTags`);
-        const discovery = asRecord(resource.discovery, `${field}.discovery`);
-        assertExactKeys(discovery, ['freshness', 'summary'], `${field}.discovery`);
-        validateFreshness(discovery.freshness, `${field}.discovery.freshness`, 'lastSuccessfulRefreshAt');
-        validateJsonObject(discovery.summary, `${field}.discovery.summary`);
-        if (resource.billing !== undefined)
-            validateResourceBillingEvidence(resource.billing, `${field}.billing`);
-        if (resource.metrics !== undefined)
-            validateResourceMetrics(resource.metrics, `${field}.metrics`);
-        if (resource.recommendations !== undefined)
-            validateResourceRecommendations(resource.recommendations, `${field}.recommendations`);
-    });
-    assertUnique(stableKeys, 'artifact.resources');
-}
-function validateResourceMetrics(value, field) {
-    const metrics = asRecord(value, field);
-    assertExactKeys(metrics, ['supported', 'families'], field);
-    requiredBoolean(metrics.supported, `${field}.supported`);
-    if (!Array.isArray(metrics.families))
-        throw new Error(`${field}.families must be an array.`);
-    metrics.families.forEach((entry, index) => {
-        const family = asRecord(entry, `${field}.families[${index}]`);
-        assertExactKeys(family, ['metricFamily', 'summary', 'coverage'], `${field}.families[${index}]`);
-        requiredEnum(family.metricFamily, METRIC_FAMILIES, `${field}.families[${index}].metricFamily`);
-        validateJsonObject(family.summary, `${field}.families[${index}].summary`);
-        validateJsonObject(family.coverage, `${field}.families[${index}].coverage`);
-    });
-}
-function validateResourceRecommendations(value, field) {
-    const recommendations = asRecord(value, field);
-    assertExactKeys(recommendations, ['matchedRecommendationCount', 'sources', 'actionability', 'templateProvenance', 'counts', 'savings'], field);
-    nonNegativeInteger(recommendations.matchedRecommendationCount, `${field}.matchedRecommendationCount`);
-    stringArray(recommendations.sources, `${field}.sources`).forEach(source => requiredEnum(source, RECOMMENDATION_SOURCES, `${field}.sources`));
-    if (recommendations.actionability !== undefined) {
-        validateRecommendationActionability(recommendations.actionability, `${field}.actionability`);
-    }
-    if (recommendations.templateProvenance !== undefined)
-        validateTemplateProvenance(recommendations.templateProvenance, `${field}.templateProvenance`);
-    validateJsonObject(recommendations.counts, `${field}.counts`);
-    validateJsonObject(recommendations.savings, `${field}.savings`);
-}
-function validateTemplateProvenance(value, field) {
-    const provenance = asRecord(value, field);
-    assertExactKeys(provenance, [
-        'status',
-        'templateBackedRecommendationCount',
-        'missingTemplateRecommendationCount',
-        'internalTemplateCount',
-        'externalTemplateCount',
-        'confidenceBackedRecommendationCount',
-        'templateRecommendationWithoutConfidenceCount',
-        'lowestConfidenceSources',
-        'minimumConfidencePercentage',
-        'maximumConfidencePercentage',
-        'averageConfidencePercentage',
-    ], field);
-    requiredEnum(provenance.status, ['available-no-template-items', 'missing-template-evidence', 'missing-confidence-evidence', 'available-with-confidence'], `${field}.status`);
-    [
-        'templateBackedRecommendationCount',
-        'missingTemplateRecommendationCount',
-        'internalTemplateCount',
-        'externalTemplateCount',
-        'confidenceBackedRecommendationCount',
-        'templateRecommendationWithoutConfidenceCount',
-    ].forEach(key => nonNegativeInteger(provenance[key], `${field}.${key}`));
-    validateTemplateProvenanceSources(provenance.lowestConfidenceSources, `${field}.lowestConfidenceSources`);
-    ['minimumConfidencePercentage', 'maximumConfidencePercentage', 'averageConfidencePercentage'].forEach(key => {
-        if (provenance[key] !== undefined && (typeof provenance[key] !== 'number' || !Number.isFinite(provenance[key])))
-            throw new Error(`${field}.${key} must be finite.`);
-    });
-}
-function validateAccount(value, accountId) {
-    const account = asRecord(value, 'artifact.account');
-    assertExactKeys(account, [
-        'metadataFound',
-        'providerAccountId',
-        'cloudAccountId',
-        'accountName',
-        'validatedAt',
-        'providerPartition',
-        'summary',
-        'firstUsefulRecommendationReadiness',
-    ], 'artifact.account');
-    requiredBoolean(account.metadataFound, 'artifact.account.metadataFound');
-    assertValue(account.providerAccountId, accountId, 'artifact.account.providerAccountId');
-    ['cloudAccountId', 'accountName', 'providerPartition'].forEach(key => {
-        if (account[key] !== undefined)
-            requiredString(account[key], `artifact.account.${key}`);
-    });
-    isoTimestamp(account.validatedAt, 'artifact.account.validatedAt');
-    validateJsonObject(account.summary, 'artifact.account.summary');
-    if (account.firstUsefulRecommendationReadiness !== undefined)
-        validateJsonObject(account.firstUsefulRecommendationReadiness, 'artifact.account.firstUsefulRecommendationReadiness');
-}
-function validateStringMap(value, field) {
-    const map = asRecord(value, field);
-    Object.entries(map).forEach(([key, item]) => {
-        requiredString(key, `${field} key`);
-        requiredString(item, `${field}.${key}`);
-    });
-}

package/dist/esm/aws/portalPublicArtifactEvidenceValidation.js

@@ -1,294 +0,0 @@
-import { asRecord, assertExactKeys, assertUnique, assertValue, finiteNumber, isoTimestamp, nonNegativeInteger, requiredBoolean, requiredString, stringArray, validateFreshness, validateJsonArray, validateJsonObject, } from './portalPublicArtifactValidationCommon.js';
-export function validateAwsPortalBillingBlock(value, field, outerBilling, accountId, accountBody) {
-    const billing = asRecord(value, field);
-    const accountFields = [
-        'costViewByCurrency',
-        'groupedCosts',
-        'commitmentSpend',
-        'resourceAttribution',
-        'calendarSummary',
-        'periodSummary',
-        'spendTrend',
-        'comparison',
-    ];
-    const resourceFields = ['pricingReferenceEstimation', 'estimatedBillingAuthority'];
-    // AWS-only window evidence. Optional so artifacts published before the
-    // rolling resource window stay valid, but validated whenever present: a block
-    // that names one anchor period while its totals span three has to say so.
-    const windowFields = ['window', 'contributingBillingPeriods', 'windowCoverage'];
-    assertExactKeys(billing, ['scope', 'freshness', 'summary', 'totalsByCurrency', ...windowFields, ...(accountBody ? accountFields : resourceFields)], field);
-    validateBillingEvidenceScope(billing.scope, outerBilling, accountId, `${field}.scope`);
-    validateBillingEvidenceWindow(billing, outerBilling, field);
-    validateFreshness(billing.freshness, `${field}.freshness`, 'lastSuccessfulImportAt');
-    validateBillingSummary(billing.summary, `${field}.summary`);
-    validateBillingGroupedResult(billing.totalsByCurrency, `${field}.totalsByCurrency`);
-    if (!accountBody) {
-        if (billing.pricingReferenceEstimation !== undefined)
-            validateJsonObject(billing.pricingReferenceEstimation, `${field}.pricingReferenceEstimation`);
-        if (billing.estimatedBillingAuthority !== undefined)
-            validateJsonObject(billing.estimatedBillingAuthority, `${field}.estimatedBillingAuthority`);
-        return;
-    }
-    validateJsonArray(billing.costViewByCurrency, `${field}.costViewByCurrency`);
-    const grouped = asRecord(billing.groupedCosts, `${field}.groupedCosts`);
-    assertExactKeys(grouped, ['byChargeCategory', 'byServiceCode', 'byServiceCategory'], `${field}.groupedCosts`);
-    validateBillingGroupedResult(grouped.byChargeCategory, `${field}.groupedCosts.byChargeCategory`, 'chargeCategory');
-    validateBillingGroupedResult(grouped.byServiceCode, `${field}.groupedCosts.byServiceCode`, 'serviceCode');
-    if (grouped.byServiceCategory !== undefined)
-        validateBillingGroupedResult(grouped.byServiceCategory, `${field}.groupedCosts.byServiceCategory`, 'serviceCategory');
-    ['commitmentSpend', 'resourceAttribution', 'calendarSummary', 'periodSummary', 'spendTrend', 'comparison'].forEach(key => {
-        if (billing[key] !== undefined)
-            validateJsonObject(billing[key], `${field}.${key}`);
-    });
-}
-export function validateAwsPortalRecommendationCoverage(value, accountId, regions, field, sources, includeTrust) {
-    const recommendations = asRecord(value, field);
-    assertExactKeys(recommendations, ['sources'], field);
-    if (!Array.isArray(recommendations.sources))
-        throw new Error(`${field}.sources must be an array.`);
-    const seenSources = [];
-    recommendations.sources.forEach((entry, index) => {
-        const itemField = `${field}.sources[${index}]`;
-        const source = asRecord(entry, itemField);
-        assertExactKeys(source, includeTrust
-            ? ['source', 'scope', 'summary', 'counts', 'savings', 'sourceEvidence', 'actionHealth']
-            : ['source', 'scope', 'summary', 'counts', 'savings'], itemField);
-        const sourceName = requiredString(source.source, `${itemField}.source`);
-        if (!sources.includes(sourceName))
-            throw new Error(`${itemField}.source is not declared.`);
-        seenSources.push(sourceName);
-        const scope = asRecord(source.scope, `${itemField}.scope`);
-        assertExactKeys(scope, ['provider', 'source', 'scope', 'accountId', 'resourceRegions'], `${itemField}.scope`);
-        assertValue(scope.provider, 'aws', `${itemField}.scope.provider`);
-        assertValue(scope.source, sourceName, `${itemField}.scope.source`);
-        assertValue(scope.scope, 'account', `${itemField}.scope.scope`);
-        assertValue(scope.accountId, accountId, `${itemField}.scope.accountId`);
-        const nestedRegions = stringArray(scope.resourceRegions, `${itemField}.scope.resourceRegions`);
-        if (JSON.stringify(nestedRegions) !== JSON.stringify(regions))
-            throw new Error(`${itemField}.scope.resourceRegions must match artifact scope exactly.`);
-        validateRecommendationSummary(source.summary, `${itemField}.summary`);
-        validateRecommendationCounts(source.counts, `${itemField}.counts`);
-        validateRecommendationSavings(source.savings, `${itemField}.savings`);
-        if (source.sourceEvidence !== undefined)
-            validateRecommendationSourceEvidence(source.sourceEvidence, `${itemField}.sourceEvidence`);
-        if (source.actionHealth !== undefined)
-            validateRecommendationActionHealth(source.actionHealth, `${itemField}.actionHealth`);
-    });
-    assertUnique(seenSources, `${field}.sources`);
-}
-function validateBillingEvidenceScope(value, outerBilling, accountId, field) {
-    const scope = asRecord(value, field);
-    assertExactKeys(scope, ['provider', 'source', 'scope', 'accountId', 'reportName', 'billingPeriod'], field);
-    assertValue(scope.provider, 'aws', `${field}.provider`);
-    assertValue(scope.source, outerBilling.source, `${field}.source`);
-    assertValue(scope.scope, 'account', `${field}.scope`);
-    assertValue(scope.accountId, accountId, `${field}.accountId`);
-    assertValue(scope.reportName, outerBilling.source === 'cur' ? outerBilling.reportName : outerBilling.exportName, `${field}.reportName`);
-    if (JSON.stringify(scope.billingPeriod) !== JSON.stringify(outerBilling.billingPeriod))
-        throw new Error(`${field}.billingPeriod must match artifact scope exactly.`);
-}
-/**
- * Validates the rolling window a billing block measures, and binds it to the
- * anchor period the artifact scope names.
- *
- * The window may start inside the preceding billing period — that is the whole
- * point of a run-anchored rolling 30 days — but it must end no later than the
- * day after the anchor period ends, and every period it claims contributed must
- * form an adjacent chain that covers it, or the block must admit
- * `partial-billing-period-coverage`.
- */
-function validateBillingEvidenceWindow(billing, outerBilling, field) {
-    const hasWindow = billing.window !== undefined;
-    if (billing.contributingBillingPeriods !== undefined && !hasWindow)
-        throw new Error(`${field}.contributingBillingPeriods requires ${field}.window.`);
-    if (billing.windowCoverage !== undefined && !hasWindow)
-        throw new Error(`${field}.windowCoverage requires ${field}.window.`);
-    if (!hasWindow)
-        return;
-    const window = asRecord(billing.window, `${field}.window`);
-    assertExactKeys(window, ['kind', 'dayCount', 'startDateInclusive', 'endDateExclusive'], `${field}.window`);
-    assertValue(window.kind, 'last-30-days', `${field}.window.kind`);
-    assertValue(window.dayCount, 30, `${field}.window.dayCount`);
-    const startDateInclusive = utcDate(window.startDateInclusive, `${field}.window.startDateInclusive`);
-    const endDateExclusive = utcDate(window.endDateExclusive, `${field}.window.endDateExclusive`);
-    if (shiftUtcDate(endDateExclusive, -30) !== startDateInclusive)
-        throw new Error(`${field}.window must cover exactly 30 UTC days.`);
-    if (endDateExclusive > shiftUtcDate(outerBilling.billingPeriod.end, 1))
-        throw new Error(`${field}.window.endDateExclusive must not run past the day after the artifact billing period.`);
-    if (billing.contributingBillingPeriods === undefined)
-        return;
-    if (!Array.isArray(billing.contributingBillingPeriods))
-        throw new Error(`${field}.contributingBillingPeriods must be an array.`);
-    const periods = billing.contributingBillingPeriods.map((entry, index) => {
-        const itemField = `${field}.contributingBillingPeriods[${index}]`;
-        const period = asRecord(entry, itemField);
-        assertExactKeys(period, ['start', 'end'], itemField);
-        const start = utcDate(period.start, `${itemField}.start`);
-        const end = utcDate(period.end, `${itemField}.end`);
-        if (end < start)
-            throw new Error(`${itemField}.end must not precede ${itemField}.start.`);
-        return { start, end };
-    });
-    assertUnique(periods.map(period => `${period.start}|${period.end}`), `${field}.contributingBillingPeriods`);
-    if (periods.some((period, index) => index > 0 && period.start <= periods[index - 1].start))
-        throw new Error(`${field}.contributingBillingPeriods must be ordered by start date.`);
-    const anchor = `${outerBilling.billingPeriod.start}|${outerBilling.billingPeriod.end}`;
-    if (periods.length > 0 && !periods.some(period => `${period.start}|${period.end}` === anchor))
-        throw new Error(`${field}.contributingBillingPeriods must include the artifact billing period.`);
-    const complete = periods.length > 0 &&
-        periods[0].start <= startDateInclusive &&
-        periods[periods.length - 1].end >= shiftUtcDate(endDateExclusive, -1) &&
-        periods.every((period, index) => index === 0 || shiftUtcDate(periods[index - 1].end, 1) === period.start);
-    const coverage = billing.windowCoverage;
-    if (coverage !== undefined && coverage !== 'complete' && coverage !== 'partial-billing-period-coverage')
-        throw new Error(`${field}.windowCoverage must be complete or partial-billing-period-coverage.`);
-    if (coverage === 'complete' && !complete)
-        throw new Error(`${field}.windowCoverage claims complete coverage its contributingBillingPeriods do not provide.`);
-}
-function utcDate(value, field) {
-    const date = requiredString(value, field);
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || new Date(`${date}T00:00:00.000Z`).toISOString().slice(0, 10) !== date)
-        throw new Error(`${field} must be a YYYY-MM-DD UTC date.`);
-    return date;
-}
-function shiftUtcDate(date, days) {
-    const parsed = new Date(`${date}T00:00:00.000Z`);
-    parsed.setUTCDate(parsed.getUTCDate() + days);
-    return parsed.toISOString().slice(0, 10);
-}
-function validateBillingSummary(value, field) {
-    const summary = asRecord(value, field);
-    assertExactKeys(summary, ['totalPersistedExpenseCount', 'emptyScope', 'metadataFound', 'metadataMatchesRequestedBillingPeriod'], field);
-    nonNegativeInteger(summary.totalPersistedExpenseCount, `${field}.totalPersistedExpenseCount`);
-    requiredBoolean(summary.emptyScope, `${field}.emptyScope`);
-    requiredBoolean(summary.metadataFound, `${field}.metadataFound`);
-    requiredBoolean(summary.metadataMatchesRequestedBillingPeriod, `${field}.metadataMatchesRequestedBillingPeriod`);
-}
-function validateBillingGroupedResult(value, field, label) {
-    const result = asRecord(value, field);
-    assertExactKeys(result, ['totalGroupCount', 'returnedGroupCount', 'truncated', 'items'], field);
-    const total = nonNegativeInteger(result.totalGroupCount, `${field}.totalGroupCount`);
-    const returned = nonNegativeInteger(result.returnedGroupCount, `${field}.returnedGroupCount`);
-    requiredBoolean(result.truncated, `${field}.truncated`);
-    if (returned > total)
-        throw new Error(`${field}.returnedGroupCount must not exceed totalGroupCount.`);
-    if (!Array.isArray(result.items) || result.items.length !== returned)
-        throw new Error(`${field}.items length must equal returnedGroupCount.`);
-    const identities = [];
-    result.items.forEach((entry, index) => {
-        const itemField = `${field}.items[${index}]`;
-        const item = asRecord(entry, itemField);
-        assertExactKeys(item, [...(label ? [label] : []), 'currency', 'expenseCount', 'baseCostAmount', 'amortizedCostAmount', 'amortizedExpenseCount'], itemField);
-        if (label)
-            requiredString(item[label], `${itemField}.${label}`);
-        const currency = requiredString(item.currency, `${itemField}.currency`);
-        nonNegativeInteger(item.expenseCount, `${itemField}.expenseCount`);
-        finiteNumber(item.baseCostAmount, `${itemField}.baseCostAmount`);
-        if (item.amortizedCostAmount !== undefined)
-            finiteNumber(item.amortizedCostAmount, `${itemField}.amortizedCostAmount`);
-        if (item.amortizedExpenseCount !== undefined)
-            nonNegativeInteger(item.amortizedExpenseCount, `${itemField}.amortizedExpenseCount`);
-        identities.push(`${label ? String(item[label]) : ''}|${currency}`);
-    });
-    assertUnique(identities, `${field}.items`);
-}
-function validateRecommendationSummary(value, field) {
-    const summary = asRecord(value, field);
-    const counts = [
-        'totalStateCount',
-        'currentStateCount',
-        'missingStateCount',
-        'snapshotBackedCount',
-        'orphanSnapshotCount',
-        'matchedStateCount',
-        'filteredOutStateCount',
-    ];
-    assertExactKeys(summary, [...counts, 'emptyScope', 'emptyResult'], field);
-    counts.forEach(key => nonNegativeInteger(summary[key], `${field}.${key}`));
-    requiredBoolean(summary.emptyScope, `${field}.emptyScope`);
-    requiredBoolean(summary.emptyResult, `${field}.emptyResult`);
-}
-function validateRecommendationCounts(value, field) {
-    const counts = asRecord(value, field);
-    const groups = [
-        ['byLifecycleStatus', 'lifecycleStatus'],
-        ['bySourcePresence', 'sourcePresence'],
-        ['byCategory', 'category'],
-        ['byRegion', 'region'],
-        ['bySourceService', 'sourceService'],
-        ['byResourceType', 'resourceType'],
-        ['byActionType', 'actionType'],
-        ['byImplementationEffort', 'implementationEffort'],
-    ];
-    assertExactKeys(counts, groups.map(([group]) => group), field);
-    groups.forEach(([group, label]) => validateCountGroup(counts[group], `${field}.${group}`, label));
-}
-function validateCountGroup(value, field, label) {
-    if (!Array.isArray(value))
-        throw new Error(`${field} must be an array.`);
-    const identities = [];
-    value.forEach((entry, index) => {
-        const item = asRecord(entry, `${field}[${index}]`);
-        assertExactKeys(item, [label, 'count'], `${field}[${index}]`);
-        identities.push(requiredString(item[label], `${field}[${index}].${label}`));
-        nonNegativeInteger(item.count, `${field}[${index}].count`);
-    });
-    assertUnique(identities, field);
-}
-function validateRecommendationSavings(value, field) {
-    const savings = asRecord(value, field);
-    const counts = [
-        'snapshotBackedMatchedCount',
-        'positiveEstimatedSavingsRecommendationCount',
-        'nonPositiveEstimatedSavingsCount',
-        'missingEstimatedSavingsCount',
-        'missingCurrencyCodeCount',
-    ];
-    assertExactKeys(savings, [...counts, 'emptySavings', 'mixedCurrencies', 'byCurrency'], field);
-    counts.forEach(key => nonNegativeInteger(savings[key], `${field}.${key}`));
-    requiredBoolean(savings.emptySavings, `${field}.emptySavings`);
-    requiredBoolean(savings.mixedCurrencies, `${field}.mixedCurrencies`);
-    if (!Array.isArray(savings.byCurrency))
-        throw new Error(`${field}.byCurrency must be an array.`);
-    const currencies = [];
-    savings.byCurrency.forEach((entry, index) => {
-        const itemField = `${field}.byCurrency[${index}]`;
-        const item = asRecord(entry, itemField);
-        assertExactKeys(item, ['currencyCode', 'recommendationCount', 'totalEstimatedMonthlySavings'], itemField);
-        currencies.push(requiredString(item.currencyCode, `${itemField}.currencyCode`));
-        nonNegativeInteger(item.recommendationCount, `${itemField}.recommendationCount`);
-        finiteNumber(item.totalEstimatedMonthlySavings, `${itemField}.totalEstimatedMonthlySavings`);
-    });
-    assertUnique(currencies, `${field}.byCurrency`);
-}
-export function validateRecommendationSourceEvidence(value, field) {
-    const evidence = asRecord(value, field);
-    const baseKeys = [
-        'totalStateCount',
-        'currentStateCount',
-        'missingStateCount',
-        'snapshotBackedCount',
-        'orphanSnapshotCount',
-        'matchedStateCount',
-        'filteredOutStateCount',
-        'emptyScope',
-        'emptyResult',
-    ];
-    assertExactKeys(evidence, [...baseKeys, 'partialSourceEvidence', 'oldestRecommendationSynchronizedAt', 'latestRecommendationSynchronizedAt', 'exactScopeCoverage'], field);
-    baseKeys.filter(key => !['emptyScope', 'emptyResult'].includes(key)).forEach(key => nonNegativeInteger(evidence[key], `${field}.${key}`));
-    requiredBoolean(evidence.emptyScope, `${field}.emptyScope`);
-    requiredBoolean(evidence.emptyResult, `${field}.emptyResult`);
-    requiredBoolean(evidence.partialSourceEvidence, `${field}.partialSourceEvidence`);
-    if (evidence.oldestRecommendationSynchronizedAt !== undefined)
-        isoTimestamp(evidence.oldestRecommendationSynchronizedAt, `${field}.oldestRecommendationSynchronizedAt`);
-    if (evidence.latestRecommendationSynchronizedAt !== undefined)
-        isoTimestamp(evidence.latestRecommendationSynchronizedAt, `${field}.latestRecommendationSynchronizedAt`);
-    if (evidence.exactScopeCoverage !== undefined)
-        validateJsonObject(evidence.exactScopeCoverage, `${field}.exactScopeCoverage`);
-}
-export function validateRecommendationActionHealth(value, field) {
-    const health = asRecord(value, field);
-    assertExactKeys(health, ['latestActionCount', 'byLatestActionStatus'], field);
-    nonNegativeInteger(health.latestActionCount, `${field}.latestActionCount`);
-    validateCountGroup(health.byLatestActionStatus, `${field}.byLatestActionStatus`, 'status');
-}