@spottoai/types-package 1.0.2-beta.354 → 1.0.2-beta.356

package/dist/esm/aws/portalPublicArtifactNestedEvidenceValidation.js

@@ -0,0 +1,397 @@
+import { asRecord, assertExactKeys, assertUnique, assertValue, finiteNumber, isoTimestamp, nonNegativeInteger, requiredBoolean, requiredEnum, requiredString, stringArray, } from './portalPublicArtifactValidationCommon.js';
+import { validateRecommendationActionHealth, validateRecommendationSourceEvidence } from './portalPublicArtifactEvidenceValidation.js';
+const ACTION_STATUSES = ['accepted', 'completed', 'failed', 'retryable-failure', 'skipped'];
+const ACTION_TYPES = ['DeleteDBInstance', 'DeleteNatGateway', 'ModifyVolume', 'ModifyStorage', 'Rightsize'];
+const PROVIDER_ACTIONS = [
+    'rds-modify-db-cluster-storage-type',
+    'autoscaling-update-group-instance-refresh',
+    'ec2-modify-volume',
+    'ec2-stop-modify-start-instance-type',
+    'ecs-register-task-definition-update-service',
+    'ec2-delete-nat-gateway',
+    'lambda-update-function-configuration',
+    'rds-delete-db-instance',
+    'rds-modify-db-instance',
+];
+const SKIP_REASONS = [
+    'recommendation-state-not-found',
+    'source-recommendation-missing',
+    'source-recommendation-not-found',
+    'published-version-immutable',
+    'provider-preflight-conflict',
+    'provider-preflight-unsupported',
+    'unsupported-recommendation-shape',
+    'no-effective-provider-change',
+];
+const RECOMMENDATION_SOURCES = [
+    'custom',
+    'compute-optimizer',
+    'cost-optimization-hub',
+    'resilience-hub',
+    'security-hub',
+    'trusted-advisor',
+    'well-architected',
+];
+export function validateResourceBillingEvidence(value, field) {
+    const billing = asRecord(value, field);
+    assertExactKeys(billing, ['costProvenance', 'matchedExpenseCount', 'totalsByCurrency', 'costViewByCurrency', 'commitmentSpend', 'benefitsCoverage', 'coverageWarning'], field);
+    const provenance = asRecord(billing.costProvenance, `${field}.costProvenance`);
+    assertExactKeys(provenance, ['costSource', 'costSourceConfidence'], `${field}.costProvenance`);
+    assertValue(provenance.costSource, 'billing', `${field}.costProvenance.costSource`);
+    assertValue(provenance.costSourceConfidence, 'high', `${field}.costProvenance.costSourceConfidence`);
+    nonNegativeInteger(billing.matchedExpenseCount, `${field}.matchedExpenseCount`);
+    validateCostTotals(billing.totalsByCurrency, `${field}.totalsByCurrency`);
+    validateCostViews(billing.costViewByCurrency, `${field}.costViewByCurrency`);
+    validateCommitmentSpend(billing.commitmentSpend, `${field}.commitmentSpend`);
+    if (billing.benefitsCoverage !== undefined)
+        validateBenefitCoverage(billing.benefitsCoverage, `${field}.benefitsCoverage`);
+    if (billing.coverageWarning !== undefined)
+        validateBenefitWarning(billing.coverageWarning, `${field}.coverageWarning`);
+}
+export function validateRecommendationActionability(value, field) {
+    const actionability = asRecord(value, field);
+    assertExactKeys(actionability, ['latestActionStableMaterializationKey', 'latestActionExecution', 'savingsVerification'], field);
+    requiredString(actionability.latestActionStableMaterializationKey, `${field}.latestActionStableMaterializationKey`);
+    validateLatestAction(actionability.latestActionExecution, `${field}.latestActionExecution`);
+    if (actionability.savingsVerification !== undefined)
+        validateSavingsVerification(actionability.savingsVerification, `${field}.savingsVerification`);
+}
+export function validateTemplateProvenanceSources(value, field) {
+    if (!Array.isArray(value))
+        throw new Error(`${field} must be an array.`);
+    const identities = [];
+    value.forEach((entry, index) => {
+        const itemField = `${field}[${index}]`;
+        const source = asRecord(entry, itemField);
+        assertExactKeys(source, [
+            'recommendationCode',
+            'templateId',
+            'relativePath',
+            'source',
+            'format',
+            'confidencePercentage',
+            'confidenceReason',
+            'primarySourceUrl',
+            'firstPartyValidationSourceCount',
+            'communitySourceCount',
+        ], itemField);
+        const recommendationCode = requiredString(source.recommendationCode, `${itemField}.recommendationCode`);
+        const relativePath = requiredString(source.relativePath, `${itemField}.relativePath`);
+        identities.push(`${recommendationCode}|${relativePath}`);
+        requiredString(source.templateId, `${itemField}.templateId`);
+        requiredEnum(source.source, ['internal', 'external'], `${itemField}.source`);
+        requiredEnum(source.format, ['canonical-v1', 'external-catalog-v1'], `${itemField}.format`);
+        if (source.confidencePercentage !== undefined)
+            percentage(source.confidencePercentage, `${itemField}.confidencePercentage`);
+        if (source.confidenceReason !== undefined)
+            requiredString(source.confidenceReason, `${itemField}.confidenceReason`);
+        if (source.primarySourceUrl !== undefined)
+            httpsUrl(source.primarySourceUrl, `${itemField}.primarySourceUrl`);
+        nonNegativeInteger(source.firstPartyValidationSourceCount, `${itemField}.firstPartyValidationSourceCount`);
+        nonNegativeInteger(source.communitySourceCount, `${itemField}.communitySourceCount`);
+    });
+    assertUnique(identities, field);
+}
+export function validateRecommendationPosture(value, field) {
+    const posture = asRecord(value, field);
+    assertExactKeys(posture, ['sourceCount', 'sources'], field);
+    const sourceCount = nonNegativeInteger(posture.sourceCount, `${field}.sourceCount`);
+    if (!Array.isArray(posture.sources) || posture.sources.length !== sourceCount)
+        throw new Error(`${field}.sources length must equal sourceCount.`);
+    const sources = [];
+    posture.sources.forEach((entry, index) => {
+        const itemField = `${field}.sources[${index}]`;
+        const source = asRecord(entry, itemField);
+        assertExactKeys(source, ['source', 'sourceEvidence', 'actionHealth'], itemField);
+        sources.push(requiredEnum(source.source, RECOMMENDATION_SOURCES, `${itemField}.source`));
+        if (source.sourceEvidence !== undefined)
+            validateRecommendationSourceEvidence(source.sourceEvidence, `${itemField}.sourceEvidence`);
+        if (source.actionHealth !== undefined)
+            validateRecommendationActionHealth(source.actionHealth, `${itemField}.actionHealth`);
+    });
+    assertUnique(sources, `${field}.sources`);
+}
+export function validateSavingsByCurrency(value, field) {
+    if (!Array.isArray(value))
+        throw new Error(`${field} must be an array.`);
+    const currencies = [];
+    value.forEach((entry, index) => {
+        const itemField = `${field}[${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);
+}
+function validateLatestAction(value, field) {
+    const action = asRecord(value, field);
+    const keys = [
+        'status',
+        'recordedAt',
+        'requestId',
+        'requestedAt',
+        'requestedBy',
+        'actionType',
+        'providerAction',
+        'completionMode',
+        'acceptedAt',
+        'completedAt',
+        'failedAt',
+        'providerRequestId',
+        'currentResourceSummary',
+        'recommendedResourceSummary',
+        'sourceTitle',
+        'estimatedMonthlySavings',
+        'estimatedSavingsPercentage',
+        'currencyCode',
+        'message',
+        'skipReason',
+        'implementationChanged',
+        'implementationImplemented',
+        'implementationPreviouslyImplemented',
+    ];
+    assertExactKeys(action, keys, field);
+    requiredEnum(action.status, ACTION_STATUSES, `${field}.status`);
+    const recordedAt = isoTimestamp(action.recordedAt, `${field}.recordedAt`);
+    const requestedAt = isoTimestamp(action.requestedAt, `${field}.requestedAt`);
+    if (Date.parse(requestedAt) > Date.parse(recordedAt))
+        throw new Error(`${field}.requestedAt must not exceed recordedAt.`);
+    requiredString(action.requestId, `${field}.requestId`);
+    assertValue(action.requestedBy, 'manual', `${field}.requestedBy`);
+    requiredEnum(action.actionType, ACTION_TYPES, `${field}.actionType`);
+    requiredEnum(action.providerAction, PROVIDER_ACTIONS, `${field}.providerAction`);
+    assertValue(action.completionMode, 'provider-poll', `${field}.completionMode`);
+    ['acceptedAt', 'completedAt', 'failedAt'].forEach(key => {
+        if (action[key] !== undefined)
+            isoTimestamp(action[key], `${field}.${key}`);
+    });
+    ['providerRequestId', 'currentResourceSummary', 'recommendedResourceSummary', 'sourceTitle', 'currencyCode', 'message'].forEach(key => {
+        if (action[key] !== undefined)
+            requiredString(action[key], `${field}.${key}`);
+    });
+    ['estimatedMonthlySavings', 'estimatedSavingsPercentage'].forEach(key => {
+        if (action[key] !== undefined)
+            finiteNumber(action[key], `${field}.${key}`);
+    });
+    if (action.skipReason !== undefined)
+        requiredEnum(action.skipReason, SKIP_REASONS, `${field}.skipReason`);
+    ['implementationChanged', 'implementationImplemented', 'implementationPreviouslyImplemented'].forEach(key => {
+        if (action[key] !== undefined)
+            requiredBoolean(action[key], `${field}.${key}`);
+    });
+}
+function validateSavingsVerification(value, field) {
+    const verification = asRecord(value, field);
+    const required = [
+        'verificationStatus',
+        'artifactType',
+        'actionRequestId',
+        'actionCompletedAt',
+        'postActionEvidenceStatus',
+        'postActionEvidenceReason',
+    ];
+    const optional = [
+        'postActionArtifactGeneratedAt',
+        'postActionRefreshRequestId',
+        'postActionPendingRefreshRequestedAt',
+        'postActionPendingRefreshUpdatedAt',
+        'postActionPendingRefreshSummary',
+        'postActionRetainedRefreshAttemptSummary',
+        'postActionSourcePresence',
+        'actionEstimatedMonthlySavings',
+        'actionEstimatedSavingsPercentage',
+        'actionCurrencyCode',
+        'currentEstimatedMonthlySavings',
+        'currentEstimatedSavingsPercentage',
+        'currentCurrencyCode',
+        'currencyCodesMatch',
+    ];
+    assertExactKeys(verification, [...required, ...optional], field);
+    requiredEnum(verification.verificationStatus, [
+        'pending-post-action-refresh',
+        'recommendation-absent-after-refresh',
+        'recommendation-still-present-after-refresh',
+        'post-action-evidence-truncated',
+    ], `${field}.verificationStatus`);
+    assertValue(verification.artifactType, 'recommendations', `${field}.artifactType`);
+    requiredString(verification.actionRequestId, `${field}.actionRequestId`);
+    isoTimestamp(verification.actionCompletedAt, `${field}.actionCompletedAt`);
+    requiredEnum(verification.postActionEvidenceStatus, ['qualified', 'refresh-pending', 'missing', 'stale', 'unqualified'], `${field}.postActionEvidenceStatus`);
+    requiredEnum(verification.postActionEvidenceReason, [
+        'qualified-post-action-artifact',
+        'canonical-refresh-row-pending',
+        'canonical-refresh-row-missing',
+        'artifact-generated-before-action-completion',
+        'artifact-refresh-request-mismatch',
+        'artifact-refresh-trigger-mismatch',
+        'artifact-changed-key-missing',
+        'artifact-type-mismatch',
+    ], `${field}.postActionEvidenceReason`);
+    ['postActionArtifactGeneratedAt', 'postActionPendingRefreshRequestedAt', 'postActionPendingRefreshUpdatedAt'].forEach(key => {
+        if (verification[key] !== undefined)
+            isoTimestamp(verification[key], `${field}.${key}`);
+    });
+    if (verification.postActionRefreshRequestId !== undefined)
+        requiredString(verification.postActionRefreshRequestId, `${field}.postActionRefreshRequestId`);
+    if (verification.postActionPendingRefreshSummary !== undefined)
+        validatePendingRefresh(verification.postActionPendingRefreshSummary, `${field}.postActionPendingRefreshSummary`);
+    if (verification.postActionRetainedRefreshAttemptSummary !== undefined)
+        validateRefreshAttempts(verification.postActionRetainedRefreshAttemptSummary, `${field}.postActionRetainedRefreshAttemptSummary`);
+    if (verification.postActionSourcePresence !== undefined)
+        requiredEnum(verification.postActionSourcePresence, ['current', 'missing'], `${field}.postActionSourcePresence`);
+    optional
+        .filter(key => key.includes('Estimated'))
+        .forEach(key => {
+        if (verification[key] !== undefined)
+            finiteNumber(verification[key], `${field}.${key}`);
+    });
+    ['actionCurrencyCode', 'currentCurrencyCode'].forEach(key => {
+        if (verification[key] !== undefined)
+            requiredString(verification[key], `${field}.${key}`);
+    });
+    if (verification.currencyCodesMatch !== undefined)
+        requiredBoolean(verification.currencyCodesMatch, `${field}.currencyCodesMatch`);
+}
+function validatePendingRefresh(value, field) {
+    const summary = asRecord(value, field);
+    assertExactKeys(summary, ['pendingArtifactCount', 'pendingArtifactTypes', 'oldestPendingRefreshUpdatedAt', 'newestPendingRefreshUpdatedAt', 'executionAttemptSummary'], field);
+    nonNegativeInteger(summary.pendingArtifactCount, `${field}.pendingArtifactCount`);
+    stringArray(summary.pendingArtifactTypes, `${field}.pendingArtifactTypes`).forEach(type => requiredEnum(type, ['recommendations', 'resource-recommendations', 'resource-type-recommendations'], `${field}.pendingArtifactTypes`));
+    ['oldestPendingRefreshUpdatedAt', 'newestPendingRefreshUpdatedAt'].forEach(key => {
+        if (summary[key] !== undefined)
+            isoTimestamp(summary[key], `${field}.${key}`);
+    });
+    if (summary.executionAttemptSummary !== undefined)
+        validateRefreshAttempts(summary.executionAttemptSummary, `${field}.executionAttemptSummary`);
+}
+function validateRefreshAttempts(value, field) {
+    const summary = asRecord(value, field);
+    assertExactKeys(summary, ['attemptedArtifactCount', 'failedAttemptCount', 'supersededAttemptCount', 'attemptReasons', 'oldestAttemptedAt', 'newestAttemptedAt'], field);
+    ['attemptedArtifactCount', 'failedAttemptCount', 'supersededAttemptCount'].forEach(key => nonNegativeInteger(summary[key], `${field}.${key}`));
+    stringArray(summary.attemptReasons, `${field}.attemptReasons`);
+    ['oldestAttemptedAt', 'newestAttemptedAt'].forEach(key => {
+        if (summary[key] !== undefined)
+            isoTimestamp(summary[key], `${field}.${key}`);
+    });
+}
+function validateCommitmentSpend(value, field) {
+    const spend = asRecord(value, field);
+    assertExactKeys(spend, [
+        'expenseCountWithCommitmentEvidence',
+        'expenseCountWithoutCommitmentEvidence',
+        'totalsByCurrency',
+        'costViewByCurrency',
+        'groupedByAmortizationSource',
+    ], field);
+    nonNegativeInteger(spend.expenseCountWithCommitmentEvidence, `${field}.expenseCountWithCommitmentEvidence`);
+    nonNegativeInteger(spend.expenseCountWithoutCommitmentEvidence, `${field}.expenseCountWithoutCommitmentEvidence`);
+    validateCostTotals(spend.totalsByCurrency, `${field}.totalsByCurrency`);
+    validateCostViews(spend.costViewByCurrency, `${field}.costViewByCurrency`);
+    if (!Array.isArray(spend.groupedByAmortizationSource))
+        throw new Error(`${field}.groupedByAmortizationSource must be an array.`);
+    const sources = [];
+    spend.groupedByAmortizationSource.forEach((entry, index) => {
+        const itemField = `${field}.groupedByAmortizationSource[${index}]`;
+        const source = asRecord(entry, itemField);
+        assertExactKeys(source, ['amortizationSource', 'expenseCount', 'totalsByCurrency', 'costViewByCurrency'], itemField);
+        sources.push(requiredEnum(source.amortizationSource, ['reservation-effective-cost', 'savings-plan-effective-cost'], `${itemField}.amortizationSource`));
+        nonNegativeInteger(source.expenseCount, `${itemField}.expenseCount`);
+        validateCostTotals(source.totalsByCurrency, `${itemField}.totalsByCurrency`);
+        validateCostViews(source.costViewByCurrency, `${itemField}.costViewByCurrency`);
+    });
+    assertUnique(sources, `${field}.groupedByAmortizationSource`);
+}
+function validateBenefitCoverage(value, field) {
+    const coverage = asRecord(value, field);
+    assertExactKeys(coverage, ['authority', 'status', 'matchedExpenseCount', 'coveredExpenseCount', 'unclassifiedExpenseCount', 'byBenefitType'], field);
+    assertValue(coverage.authority, 'persisted-billing-expense-amortization', `${field}.authority`);
+    requiredEnum(coverage.status, ['available', 'partial-persisted-evidence', 'missing-persisted-evidence'], `${field}.status`);
+    ['matchedExpenseCount', 'coveredExpenseCount', 'unclassifiedExpenseCount'].forEach(key => nonNegativeInteger(coverage[key], `${field}.${key}`));
+    if (!Array.isArray(coverage.byBenefitType))
+        throw new Error(`${field}.byBenefitType must be an array.`);
+    const types = [];
+    coverage.byBenefitType.forEach((entry, index) => {
+        const itemField = `${field}.byBenefitType[${index}]`;
+        const benefit = asRecord(entry, itemField);
+        assertExactKeys(benefit, ['benefitType', 'amortizationSource', 'expenseCount', 'totalsByCurrency', 'costViewByCurrency'], itemField);
+        types.push(requiredEnum(benefit.benefitType, ['reserved-instance', 'savings-plan'], `${itemField}.benefitType`));
+        requiredEnum(benefit.amortizationSource, ['reservation-effective-cost', 'savings-plan-effective-cost'], `${itemField}.amortizationSource`);
+        nonNegativeInteger(benefit.expenseCount, `${itemField}.expenseCount`);
+        validateCostTotals(benefit.totalsByCurrency, `${itemField}.totalsByCurrency`);
+        validateCostViews(benefit.costViewByCurrency, `${itemField}.costViewByCurrency`);
+    });
+    assertUnique(types, `${field}.byBenefitType`);
+}
+function validateBenefitWarning(value, field) {
+    const warning = asRecord(value, field);
+    assertExactKeys(warning, ['code', 'severity', 'matchedExpenseCount', 'unclassifiedExpenseCount', 'message'], field);
+    requiredEnum(warning.code, ['ri-sp-coverage-evidence-missing', 'ri-sp-coverage-evidence-partial'], `${field}.code`);
+    assertValue(warning.severity, 'warning', `${field}.severity`);
+    nonNegativeInteger(warning.matchedExpenseCount, `${field}.matchedExpenseCount`);
+    nonNegativeInteger(warning.unclassifiedExpenseCount, `${field}.unclassifiedExpenseCount`);
+    requiredString(warning.message, `${field}.message`);
+}
+function validateCostTotals(value, field) {
+    if (!Array.isArray(value))
+        throw new Error(`${field} must be an array.`);
+    const currencies = [];
+    value.forEach((entry, index) => {
+        const itemField = `${field}[${index}]`;
+        const total = asRecord(entry, itemField);
+        assertExactKeys(total, ['currency', 'expenseCount', 'baseCostAmount', 'amortizedCostAmount', 'amortizedExpenseCount'], itemField);
+        currencies.push(requiredString(total.currency, `${itemField}.currency`));
+        nonNegativeInteger(total.expenseCount, `${itemField}.expenseCount`);
+        finiteNumber(total.baseCostAmount, `${itemField}.baseCostAmount`);
+        if (total.amortizedCostAmount !== undefined)
+            finiteNumber(total.amortizedCostAmount, `${itemField}.amortizedCostAmount`);
+        if (total.amortizedExpenseCount !== undefined)
+            nonNegativeInteger(total.amortizedExpenseCount, `${itemField}.amortizedExpenseCount`);
+    });
+    assertUnique(currencies, field);
+}
+function validateCostViews(value, field) {
+    if (!Array.isArray(value))
+        throw new Error(`${field} must be an array.`);
+    const currencies = [];
+    value.forEach((entry, index) => {
+        const itemField = `${field}[${index}]`;
+        const view = asRecord(entry, itemField);
+        assertExactKeys(view, [
+            'currency',
+            'actualCostAmount',
+            'amortizedCostAmount',
+            'amortizedExpenseCount',
+            'amortizationCoverageState',
+            'actualVsAmortizedDeltaAmount',
+            'commitmentCoverageState',
+            'showAmortizedCosts',
+        ], itemField);
+        currencies.push(requiredString(view.currency, `${itemField}.currency`));
+        finiteNumber(view.actualCostAmount, `${itemField}.actualCostAmount`);
+        ['amortizedCostAmount', 'actualVsAmortizedDeltaAmount'].forEach(key => {
+            if (view[key] !== undefined)
+                finiteNumber(view[key], `${itemField}.${key}`);
+        });
+        if (view.amortizedExpenseCount !== undefined)
+            nonNegativeInteger(view.amortizedExpenseCount, `${itemField}.amortizedExpenseCount`);
+        if (view.amortizationCoverageState !== undefined)
+            requiredEnum(view.amortizationCoverageState, ['complete', 'partial', 'none', 'unavailable'], `${itemField}.amortizationCoverageState`);
+        requiredEnum(view.commitmentCoverageState, ['discounted', 'no-amortized-cost', 'no-delta', 'amortized-exceeds-base', 'partial-amortized-cost', 'amortization-coverage-unavailable'], `${itemField}.commitmentCoverageState`);
+        requiredBoolean(view.showAmortizedCosts, `${itemField}.showAmortizedCosts`);
+    });
+    assertUnique(currencies, field);
+}
+function percentage(value, field) {
+    const result = finiteNumber(value, field);
+    if (result < 0 || result > 100)
+        throw new Error(`${field} must be between 0 and 100.`);
+    return result;
+}
+function httpsUrl(value, field) {
+    const result = requiredString(value, field);
+    if (!result.startsWith('https://'))
+        throw new Error(`${field} must be an HTTPS URL.`);
+    return result;
+}

package/dist/esm/aws/portalPublicArtifactValidation.js

@@ -0,0 +1,2 @@
+export { validateAwsPortalAccountSummaryDetailArtifact, validateAwsPortalResourceCollectionDetailArtifact, } from './portalPublicArtifactCurrentValidation.js';
+export { validateAwsPortalAccountSummaryAiCostSummaryArtifact, validateAwsPortalAccountSummaryAiCostSummarySiblingBinding, validateAwsPortalAccountSummaryHistoryArtifact, validateAwsPortalResourceCollectionHistoryArtifact, validateAwsPortalRetainedHistoryBodyBinding, validateAwsPortalRetainedHistoryBodyReference, } from './portalPublicArtifactHistoryAiValidation.js';

package/dist/esm/aws/portalPublicArtifactValidationCommon.js

@@ -0,0 +1,139 @@
+import { AWS_PORTAL_PUBLIC_ARTIFACT_SCHEMA_VERSION, } from './portalPublicArtifacts.js';
+import { AWS_PUBLIC_ARTIFACT_SCHEMA_VERSION } from './publicArtifacts.js';
+import { asRecord, assertAccount, assertExactKeys, assertPublicJson, assertValue, isoTimestamp, requiredEnum, requiredString, stringArray, validateBilling, validateMetricWindow, } from './pluginPublicArtifactValidationHelpers.js';
+export { asRecord, assertExactKeys, assertPublicJson, assertValue, isoTimestamp, requiredEnum, requiredString, stringArray };
+export function validatePortalEnvelope(artifact, artifactType, allowed) {
+    assertExactKeys(artifact, allowed, 'artifact');
+    assertValue(artifact.schemaVersion, AWS_PUBLIC_ARTIFACT_SCHEMA_VERSION, 'artifact.schemaVersion');
+    assertValue(artifact.portalSchemaVersion, AWS_PORTAL_PUBLIC_ARTIFACT_SCHEMA_VERSION, 'artifact.portalSchemaVersion');
+    assertValue(artifact.provider, 'aws', 'artifact.provider');
+    const accountId = requiredString(artifact.accountId, 'artifact.accountId');
+    assertAccount(accountId, accountId, 'artifact.accountId');
+    assertValue(artifact.artifactType, artifactType, 'artifact.artifactType');
+    const generation = validateGeneration(artifact.artifactGeneration, 'artifact.artifactGeneration');
+    const bodyGeneratedAt = isoTimestamp(artifact.generatedAt, 'artifact.generatedAt');
+    if (Date.parse(bodyGeneratedAt) > Date.parse(generation.generatedAt))
+        throw new Error('artifact.generatedAt must not be newer than the Portal generation.');
+    return { accountId, runId: generation.runId, portalGeneratedAt: generation.generatedAt, bodyGeneratedAt };
+}
+export function validateGeneration(value, field) {
+    const generation = asRecord(value, field);
+    assertExactKeys(generation, ['runId', 'generatedAt'], field);
+    return {
+        runId: requiredPublicIdentifier(generation.runId, `${field}.runId`),
+        generatedAt: isoTimestamp(generation.generatedAt, `${field}.generatedAt`),
+    };
+}
+export function validateResourceScope(value, accountId, field) {
+    const scope = asRecord(value, field);
+    assertExactKeys(scope, ['provider', 'accountId', 'billing', 'resourceRegions', 'metricTimeWindow', 'tagRuleScope'], field);
+    assertValue(scope.provider, 'aws', `${field}.provider`);
+    assertAccount(scope.accountId, accountId, `${field}.accountId`);
+    validateBilling(scope.billing, `${field}.billing`);
+    regionArray(scope.resourceRegions, `${field}.resourceRegions`);
+    validateMetricWindow(scope.metricTimeWindow, `${field}.metricTimeWindow`);
+    if (scope.tagRuleScope !== undefined) {
+        const tagRuleScope = asRecord(scope.tagRuleScope, `${field}.tagRuleScope`);
+        assertExactKeys(tagRuleScope, ['companyId'], `${field}.tagRuleScope`);
+        requiredString(tagRuleScope.companyId, `${field}.tagRuleScope.companyId`);
+    }
+    return value;
+}
+export function validateAccountScope(value, accountId, field) {
+    const scope = asRecord(value, field);
+    assertExactKeys(scope, ['provider', 'accountId', 'billing', 'comparisonBillingPeriod', 'resourceRegions', 'metricTimeWindow'], field);
+    assertValue(scope.provider, 'aws', `${field}.provider`);
+    assertAccount(scope.accountId, accountId, `${field}.accountId`);
+    validateBilling(scope.billing, `${field}.billing`);
+    if (scope.comparisonBillingPeriod !== undefined)
+        validatePeriod(scope.comparisonBillingPeriod, `${field}.comparisonBillingPeriod`);
+    regionArray(scope.resourceRegions, `${field}.resourceRegions`);
+    validateMetricWindow(scope.metricTimeWindow, `${field}.metricTimeWindow`);
+    return value;
+}
+export function validateHistoryAccountScope(value, accountId, field) {
+    const scope = asRecord(value, field);
+    assertExactKeys(scope, ['provider', 'accountId', 'billing', 'resourceRegions'], field);
+    assertValue(scope.provider, 'aws', `${field}.provider`);
+    assertAccount(scope.accountId, accountId, `${field}.accountId`);
+    validateBilling(scope.billing, `${field}.billing`);
+    regionArray(scope.resourceRegions, `${field}.resourceRegions`);
+}
+export function validatePeriod(value, field) {
+    const period = asRecord(value, field);
+    assertExactKeys(period, ['start', 'end'], field);
+    dateValue(period.start, `${field}.start`);
+    dateValue(period.end, `${field}.end`);
+    if (String(period.start) > String(period.end))
+        throw new Error(`${field}.start must not exceed end.`);
+}
+export function validateFreshness(value, field, timestampField) {
+    const freshness = asRecord(value, field);
+    assertExactKeys(freshness, [timestampField, timestampField === 'lastSuccessfulImportAt' ? 'hasSuccessfulImport' : 'hasSuccessfulRefresh'], field);
+    if (freshness[timestampField] !== undefined)
+        isoTimestamp(freshness[timestampField], `${field}.${timestampField}`);
+    const booleanField = timestampField === 'lastSuccessfulImportAt' ? 'hasSuccessfulImport' : 'hasSuccessfulRefresh';
+    requiredBoolean(freshness[booleanField], `${field}.${booleanField}`);
+}
+export function requiredBoolean(value, field) {
+    if (typeof value !== 'boolean')
+        throw new Error(`${field} must be a boolean.`);
+    return value;
+}
+export function nonNegativeInteger(value, field) {
+    if (!Number.isSafeInteger(value) || Number(value) < 0)
+        throw new Error(`${field} must be a non-negative safe integer.`);
+    return Number(value);
+}
+export function finiteNumber(value, field) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        throw new Error(`${field} must be a finite number.`);
+    return value;
+}
+export function validateJsonObject(value, field) {
+    asRecord(value, field);
+    assertPublicJson(value, field);
+}
+export function validateJsonArray(value, field) {
+    if (!Array.isArray(value))
+        throw new Error(`${field} must be an array.`);
+    assertPublicJson(value, field);
+    return value;
+}
+export function assertRegionsBelong(regions, allowedRegions, field) {
+    const nested = stringArray(regions, field);
+    nested.forEach(region => {
+        if (!allowedRegions.includes(region))
+            throw new Error(`${field} contains Region outside artifact scope: ${region}.`);
+    });
+}
+export function assertUnique(values, field) {
+    if (new Set(values).size !== values.length)
+        throw new Error(`${field} must not contain duplicates.`);
+}
+export function regionArray(value, field) {
+    const regions = stringArray(value, field);
+    if (regions.length === 0)
+        throw new Error(`${field} must not be empty.`);
+    assertUnique(regions, field);
+    regions.forEach(region => {
+        if (region !== 'global' && !/^[a-z]{2}(?:-gov)?-[a-z0-9-]+-\d+$/.test(region))
+            throw new Error(`${field} contains a non-canonical AWS Region: ${region}.`);
+    });
+    return regions;
+}
+export function requiredPublicIdentifier(value, field) {
+    const identifier = requiredString(value, field);
+    if (identifier.includes('/') || identifier.includes('\\') || identifier.includes('://') || identifier.includes('..'))
+        throw new Error(`${field} must not contain a physical path or URI.`);
+    return identifier;
+}
+export function dateValue(value, field) {
+    const date = requiredString(value, field);
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || Number.isNaN(Date.parse(`${date}T00:00:00.000Z`)))
+        throw new Error(`${field} must be a calendar date.`);
+    const normalized = new Date(`${date}T00:00:00.000Z`).toISOString().slice(0, 10);
+    if (normalized !== date)
+        throw new Error(`${field} must be a valid calendar date.`);
+    return date;
+}

package/dist/esm/aws/portalPublicArtifacts.js

@@ -0,0 +1,73 @@
+import { sha256AwsPluginIdentity } from './pluginPublicArtifacts.js';
+export const AWS_PORTAL_PUBLIC_ARTIFACT_SCHEMA_VERSION = 1;
+export const AWS_PORTAL_RESOURCE_COLLECTION_LOGICAL_NAME = 'resources.json.gz';
+export const AWS_PORTAL_ACCOUNT_SUMMARY_LOGICAL_NAME = 'account-summary.json.gz';
+export const AWS_PORTAL_ACCOUNT_SUMMARY_AI_COST_SUMMARY_LOGICAL_NAME = 'account-summary-ai-cost-summary.json.gz';
+export function buildAwsPortalResourceCollectionHistoryLogicalName(identitySha256) {
+    assertSha256(identitySha256, 'identitySha256');
+    return `resources-history--${identitySha256}.json.gz`;
+}
+export function buildAwsPortalAccountSummaryHistoryLogicalName(identitySha256) {
+    assertSha256(identitySha256, 'identitySha256');
+    return `account-summary-history--${identitySha256}.json.gz`;
+}
+export function buildAwsPortalResourceCollectionHistoryIdentityKey(scope, generatedAt) {
+    return [
+        'resource-collection-history',
+        scope.provider,
+        scope.accountId,
+        scope.billing.source,
+        scope.billing.source === 'cur' ? `report:${scope.billing.reportName}` : `export:${scope.billing.exportName}`,
+        scope.billing.billingPeriod.start,
+        scope.billing.billingPeriod.end,
+        scope.resourceRegions.join(','),
+        scope.metricTimeWindow.start,
+        scope.metricTimeWindow.end,
+        ...(scope.tagRuleScope ? [`tag-rules:company:${scope.tagRuleScope.companyId}`] : []),
+        generatedAt,
+    ].join('|');
+}
+export function buildAwsPortalResourceCollectionHistoryLogicalNameForScope(scope, generatedAt) {
+    return buildAwsPortalResourceCollectionHistoryLogicalName(sha256Text(buildAwsPortalResourceCollectionHistoryIdentityKey(scope, generatedAt)));
+}
+export function buildAwsPortalAccountSummaryHistoryIdentityKey(scope) {
+    return [
+        'account-summary-history',
+        scope.provider,
+        scope.accountId,
+        scope.billing.source,
+        scope.billing.source === 'cur' ? `report:${scope.billing.reportName}` : `export:${scope.billing.exportName}`,
+        scope.resourceRegions.join(','),
+        scope.billing.billingPeriod.start,
+        scope.billing.billingPeriod.end,
+    ].join('|');
+}
+export function buildAwsPortalAccountSummaryHistoryLogicalNameForScope(scope) {
+    return buildAwsPortalAccountSummaryHistoryLogicalName(sha256Text(buildAwsPortalAccountSummaryHistoryIdentityKey(scope)));
+}
+export function buildAwsPortalAccountSummaryTargetKey(scope) {
+    return [
+        'account-summary',
+        scope.provider,
+        scope.accountId,
+        scope.billing.source,
+        scope.billing.source === 'cur' ? `report:${scope.billing.reportName}` : `export:${scope.billing.exportName}`,
+        scope.billing.billingPeriod.start,
+        scope.billing.billingPeriod.end,
+        scope.resourceRegions.join(','),
+        scope.metricTimeWindow.start,
+        scope.metricTimeWindow.end,
+        ...(scope.comparisonBillingPeriod ? [`comparison:${scope.comparisonBillingPeriod.start}:${scope.comparisonBillingPeriod.end}`] : []),
+    ].join('|');
+}
+export function buildAwsPortalAccountSummaryAiCostSummaryTargetKey(scope, audience) {
+    const sourceTargetKey = buildAwsPortalAccountSummaryTargetKey(scope);
+    return `account-summary-ai-cost-summary|${sourceTargetKey.slice('account-summary|'.length)}|audience:${audience}`;
+}
+function assertSha256(value, field) {
+    if (!/^[a-f0-9]{64}$/.test(value))
+        throw new Error(`${field} must be a lowercase hexadecimal SHA-256.`);
+}
+function sha256Text(value) {
+    return sha256AwsPluginIdentity(value);
+}