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

package/dist/esm/aws/portalPublicArtifactNestedEvidenceValidation.js

@@ -1,397 +0,0 @@
-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

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

package/dist/esm/aws/portalPublicArtifactValidationCommon.js

@@ -1,139 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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);
-}