@spottoai/types-package 1.0.2-dev1138.2 → 1.0.2-dev1138.5

package/dist/esm/aws/portalOrganizationCommitmentsPlanningPublicArtifactValidation.js

@@ -0,0 +1,402 @@
+import { AWS_ORGANIZATION_COMMITMENTS_ATTRIBUTION_UNAVAILABLE_REASONS, } from './organizationCommitments.js';
+import { validateAwsOrganizationCommitmentsPlanningViewIdentity, } from './organizationCommitmentsValidation.js';
+import { AWS_ORGANIZATION_COMMITMENTS_PLANNING_LOGICAL_NAME, AWS_ORGANIZATION_COMMITMENTS_PUBLIC_ARTIFACT_SCHEMA_VERSION, } from './portalOrganizationCommitmentsPlanningPublicArtifacts.js';
+import { AWS_PORTAL_PUBLIC_ARTIFACT_SCHEMA_VERSION } from './portalPublicArtifacts.js';
+import { asRecord, assertExactKeys, assertPublicJson, assertValue, finiteNumber, isoTimestamp, requiredEnum, requiredString, validateGeneration, } from './portalPublicArtifactValidationCommon.js';
+const TOP_LEVEL_KEYS = [
+    'schemaVersion',
+    'portalSchemaVersion',
+    'provider',
+    'artifactType',
+    'artifactGeneration',
+    'logicalName',
+    'manifestRevision',
+    'version',
+    'generatedAt',
+    'month',
+    'providerScope',
+    'accounts',
+    'utilizationSummary',
+    'expirySummary',
+    'inventory',
+    'payerAggregates',
+    'sharingPosture',
+    'pricingContext',
+    'freshness',
+    'purchaseRecommendations',
+    'allocation',
+    'resourceAttribution',
+];
+/** Validates one untrusted organization Commitments Planning view without its Portal envelope. */
+export function validateAwsOrganizationCommitmentsPlanningView(value, expected) {
+    validateAwsOrganizationCommitmentsPlanningViewIdentity(value, expected);
+    validateBody(value);
+    assertPublicJson(value, 'organizationCommitmentsPlanning');
+    return value;
+}
+/** Validates one untrusted immutable AWS organization Commitments Planning artifact. */
+export function validateAwsPortalOrganizationCommitmentsPlanningArtifact(value, expected) {
+    const artifact = asRecord(value, 'artifact');
+    assertExactKeys(artifact, TOP_LEVEL_KEYS, 'artifact');
+    assertValue(artifact.schemaVersion, AWS_ORGANIZATION_COMMITMENTS_PUBLIC_ARTIFACT_SCHEMA_VERSION, 'artifact.schemaVersion');
+    assertValue(artifact.portalSchemaVersion, AWS_PORTAL_PUBLIC_ARTIFACT_SCHEMA_VERSION, 'artifact.portalSchemaVersion');
+    assertValue(artifact.provider, 'aws', 'artifact.provider');
+    assertValue(artifact.artifactType, 'organization-commitments-planning', 'artifact.artifactType');
+    assertValue(artifact.logicalName, AWS_ORGANIZATION_COMMITMENTS_PLANNING_LOGICAL_NAME, 'artifact.logicalName');
+    requiredString(artifact.manifestRevision, 'artifact.manifestRevision');
+    assertValue(artifact.version, '1.0', 'artifact.version');
+    const generation = validateGeneration(artifact.artifactGeneration, 'artifact.artifactGeneration');
+    const generatedAt = isoTimestamp(artifact.generatedAt, 'artifact.generatedAt');
+    if (Date.parse(generatedAt) > Date.parse(generation.generatedAt)) {
+        throw new Error('artifact.generatedAt must not be newer than the Portal generation.');
+    }
+    if (artifact.month !== undefined)
+        requiredString(artifact.month, 'artifact.month');
+    validateAwsOrganizationCommitmentsPlanningView(artifact, expected);
+    assertPublicJson(artifact, 'artifact');
+    return value;
+}
+function validateBody(view) {
+    records(view.accounts, 'artifact.accounts', validateAccount);
+    validateUtilizationSummary(view.utilizationSummary, 'artifact.utilizationSummary');
+    exact(view.expirySummary, ['expired', 'expiring30d', 'expiring60d', 'expiring90d', 'expiring180d'], 'artifact.expirySummary');
+    records(view.inventory, 'artifact.inventory', validateInventory);
+    records(view.payerAggregates, 'artifact.payerAggregates', validatePayerAggregate);
+    validateSharingPosture(view.sharingPosture, 'artifact.sharingPosture');
+    validatePricingContext(view.pricingContext, 'artifact.pricingContext');
+    optionalRecord(view.freshness, 'artifact.freshness', validateFreshness);
+    optionalRecords(view.purchaseRecommendations, 'artifact.purchaseRecommendations', validatePurchaseRecommendation);
+    validateAttribution(view.allocation, 'artifact.allocation', validateAllocationRecord);
+    validateAttribution(view.resourceAttribution, 'artifact.resourceAttribution', validateResourceAttributionRecord);
+}
+function validateSharingPosture(value, field) {
+    const posture = exact(value, ['status', 'reason'], field);
+    assertValue(posture.status, 'unknown', `${field}.status`);
+    assertValue(posture.reason, 'not-collected', `${field}.reason`);
+}
+function validateAccount(value, field) {
+    const account = exact(value, ['accountId', 'displayName', 'role', 'inventoryStatus', 'lastSuccessfulRefreshAt'], field);
+    requiredString(account.accountId, `${field}.accountId`);
+    optionalString(account.displayName, `${field}.displayName`);
+    requiredEnum(account.role, ['management', 'member'], `${field}.role`);
+    requiredEnum(account.inventoryStatus, ['current', 'stale', 'partial', 'unavailable'], `${field}.inventoryStatus`);
+    optionalTimestamp(account.lastSuccessfulRefreshAt, `${field}.lastSuccessfulRefreshAt`);
+}
+function validateUtilizationSummary(value, field) {
+    const summary = exact(value, ['total', 'withData', 'sevenDayAverage', 'thirtyDayAverage', 'sevenDayAggregates', 'thirtyDayAggregates', 'byBenefitType'], field);
+    nonNegative(summary.total, `${field}.total`);
+    nonNegative(summary.withData, `${field}.withData`);
+    optionalNumber(summary.sevenDayAverage, `${field}.sevenDayAverage`);
+    optionalNumber(summary.thirtyDayAverage, `${field}.thirtyDayAverage`);
+    optionalRecords(summary.sevenDayAggregates, `${field}.sevenDayAggregates`, validateWeightedAggregate);
+    optionalRecords(summary.thirtyDayAggregates, `${field}.thirtyDayAggregates`, validateWeightedAggregate);
+    records(summary.byBenefitType, `${field}.byBenefitType`, (entry, itemField) => {
+        const item = exact(entry, ['benefitType', 'total', 'withData', 'sevenDayAverage', 'thirtyDayAverage', 'sevenDayAggregates', 'thirtyDayAggregates'], itemField);
+        requiredEnum(item.benefitType, ['reservation', 'savings-plan'], `${itemField}.benefitType`);
+        nonNegative(item.total, `${itemField}.total`);
+        nonNegative(item.withData, `${itemField}.withData`);
+        optionalNumber(item.sevenDayAverage, `${itemField}.sevenDayAverage`);
+        optionalNumber(item.thirtyDayAverage, `${itemField}.thirtyDayAverage`);
+        optionalRecords(item.sevenDayAggregates, `${itemField}.sevenDayAggregates`, validateWeightedAggregate);
+        optionalRecords(item.thirtyDayAggregates, `${itemField}.thirtyDayAggregates`, validateWeightedAggregate);
+    });
+}
+function validateWeightedAggregate(value, field) {
+    const aggregate = exact(value, ['used', 'reserved', 'percentage', 'sampleCount', 'unit', 'currency'], field);
+    finiteNumber(aggregate.used, `${field}.used`);
+    finiteNumber(aggregate.reserved, `${field}.reserved`);
+    optionalNumber(aggregate.percentage, `${field}.percentage`);
+    if (aggregate.sampleCount !== undefined)
+        nonNegative(aggregate.sampleCount, `${field}.sampleCount`);
+    requiredEnum(aggregate.unit, ['hours', 'quantity', 'currency'], `${field}.unit`);
+    optionalString(aggregate.currency, `${field}.currency`);
+}
+function validateInventory(value, field) {
+    const item = exact(value, [
+        'id',
+        'benefitType',
+        'commitmentFamily',
+        'sourceKind',
+        'sourceId',
+        'provider',
+        'ownerAccountId',
+        'shape',
+        'scope',
+        'type',
+        'displayName',
+        'status',
+        'purchaseDate',
+        'expiryDate',
+        'daysToExpiry',
+        'commitmentAmount',
+        'commitmentCurrencyCode',
+        'commitmentGrain',
+        'commitmentUnit',
+        'skuName',
+        'location',
+        'term',
+        'termMonths',
+        'billingPlan',
+        'utilization',
+    ], field);
+    requiredString(item.id, `${field}.id`);
+    requiredEnum(item.benefitType, ['reservation', 'savings-plan'], `${field}.benefitType`);
+    optionalString(item.commitmentFamily, `${field}.commitmentFamily`);
+    assertValue(item.sourceKind, 'aws-native', `${field}.sourceKind`);
+    optionalString(item.sourceId, `${field}.sourceId`);
+    assertValue(item.provider, 'aws', `${field}.provider`);
+    requiredString(item.ownerAccountId, `${field}.ownerAccountId`);
+    optionalRecord(item.shape, `${field}.shape`, validateShape);
+    requiredEnum(item.scope, ['Shared', 'Single', 'ManagementGroup', 'Unknown'], `${field}.scope`);
+    requiredString(item.type, `${field}.type`);
+    optionalString(item.displayName, `${field}.displayName`);
+    requiredString(item.status, `${field}.status`);
+    optionalString(item.purchaseDate, `${field}.purchaseDate`);
+    optionalString(item.expiryDate, `${field}.expiryDate`);
+    optionalNumber(item.daysToExpiry, `${field}.daysToExpiry`);
+    optionalNumber(item.commitmentAmount, `${field}.commitmentAmount`);
+    optionalString(item.commitmentCurrencyCode, `${field}.commitmentCurrencyCode`);
+    optionalString(item.commitmentGrain, `${field}.commitmentGrain`);
+    optionalString(item.commitmentUnit, `${field}.commitmentUnit`);
+    optionalString(item.skuName, `${field}.skuName`);
+    optionalString(item.location, `${field}.location`);
+    optionalString(item.term, `${field}.term`);
+    optionalNumber(item.termMonths, `${field}.termMonths`);
+    optionalString(item.billingPlan, `${field}.billingPlan`);
+    optionalRecord(item.utilization, `${field}.utilization`, validateUtilization);
+}
+function validatePayerAggregate(value, field) {
+    const aggregate = exact(value, [
+        'benefitType',
+        'commitmentFamily',
+        'payerAccountId',
+        'windowStart',
+        'windowEnd',
+        'eligibleCost',
+        'coveredCost',
+        'uncoveredCost',
+        'coveragePercent',
+        'utilization',
+        'source',
+    ], field);
+    requiredEnum(aggregate.benefitType, ['reservation', 'savings-plan'], `${field}.benefitType`);
+    requiredString(aggregate.commitmentFamily, `${field}.commitmentFamily`);
+    requiredString(aggregate.payerAccountId, `${field}.payerAccountId`);
+    requiredString(aggregate.windowStart, `${field}.windowStart`);
+    requiredString(aggregate.windowEnd, `${field}.windowEnd`);
+    optionalRecord(aggregate.eligibleCost, `${field}.eligibleCost`, validateMoney);
+    optionalRecord(aggregate.coveredCost, `${field}.coveredCost`, validateMoney);
+    optionalRecord(aggregate.uncoveredCost, `${field}.uncoveredCost`, validateMoney);
+    optionalNumber(aggregate.coveragePercent, `${field}.coveragePercent`);
+    optionalRecord(aggregate.utilization, `${field}.utilization`, validateUtilization);
+    validateSource(aggregate.source, `${field}.source`, false);
+}
+function validatePurchaseRecommendation(value, field) {
+    const recommendation = exact(value, [
+        'id',
+        'groupKey',
+        'commitmentFamily',
+        'action',
+        'purchaseScope',
+        'payerAccountId',
+        'recommendedAccountId',
+        'source',
+        'targetShape',
+        'title',
+        'description',
+        'confidence',
+        'riskLevel',
+        'termMonths',
+        'quantity',
+        'estimatedAnnualSavings',
+        'estimatedAnnualCost',
+        'estimatedTermSavings',
+        'estimatedTermCost',
+        'notes',
+    ], field);
+    requiredString(recommendation.id, `${field}.id`);
+    requiredString(recommendation.groupKey, `${field}.groupKey`);
+    requiredString(recommendation.commitmentFamily, `${field}.commitmentFamily`);
+    requiredEnum(recommendation.action, ['buy', 'unlock', 'savings-plan', 'none'], `${field}.action`);
+    assertValue(recommendation.purchaseScope, 'payer', `${field}.purchaseScope`);
+    requiredString(recommendation.payerAccountId, `${field}.payerAccountId`);
+    optionalString(recommendation.recommendedAccountId, `${field}.recommendedAccountId`);
+    validateSource(recommendation.source, `${field}.source`, false);
+    validateShape(recommendation.targetShape, `${field}.targetShape`);
+    optionalString(recommendation.title, `${field}.title`);
+    optionalString(recommendation.description, `${field}.description`);
+    optionalString(recommendation.confidence, `${field}.confidence`);
+    optionalString(recommendation.riskLevel, `${field}.riskLevel`);
+    optionalNumber(recommendation.termMonths, `${field}.termMonths`);
+    optionalNumber(recommendation.quantity, `${field}.quantity`);
+    optionalRecord(recommendation.estimatedAnnualSavings, `${field}.estimatedAnnualSavings`, validateMoney);
+    optionalRecord(recommendation.estimatedAnnualCost, `${field}.estimatedAnnualCost`, validateMoney);
+    optionalRecord(recommendation.estimatedTermSavings, `${field}.estimatedTermSavings`, validateMoney);
+    optionalRecord(recommendation.estimatedTermCost, `${field}.estimatedTermCost`, validateMoney);
+    optionalStrings(recommendation.notes, `${field}.notes`);
+}
+function validateAttribution(value, field, validateRecord) {
+    const evidence = asRecord(value, field);
+    if (evidence.status === 'unavailable') {
+        assertExactKeys(evidence, ['status', 'reason'], field);
+        requiredEnum(evidence.reason, AWS_ORGANIZATION_COMMITMENTS_ATTRIBUTION_UNAVAILABLE_REASONS, `${field}.reason`);
+        return;
+    }
+    assertValue(evidence.status, 'available', `${field}.status`);
+    assertExactKeys(evidence, ['status', 'source', 'records'], field);
+    validateSource(evidence.source, `${field}.source`, true);
+    records(evidence.records, `${field}.records`, validateRecord, true);
+}
+function validateAllocationRecord(value, field) {
+    const record = exact(value, [
+        'beneficiaryAccountId',
+        'ownerAccountId',
+        'commitmentId',
+        'benefitType',
+        'commitmentFamily',
+        'windowStart',
+        'windowEnd',
+        'eligibleCost',
+        'coveredCost',
+        'uncoveredCost',
+    ], field);
+    requiredString(record.beneficiaryAccountId, `${field}.beneficiaryAccountId`);
+    optionalString(record.ownerAccountId, `${field}.ownerAccountId`);
+    optionalString(record.commitmentId, `${field}.commitmentId`);
+    requiredEnum(record.benefitType, ['reservation', 'savings-plan'], `${field}.benefitType`);
+    requiredString(record.commitmentFamily, `${field}.commitmentFamily`);
+    requiredString(record.windowStart, `${field}.windowStart`);
+    requiredString(record.windowEnd, `${field}.windowEnd`);
+    optionalRecord(record.eligibleCost, `${field}.eligibleCost`, validateMoney);
+    optionalRecord(record.coveredCost, `${field}.coveredCost`, validateMoney);
+    optionalRecord(record.uncoveredCost, `${field}.uncoveredCost`, validateMoney);
+}
+function validateResourceAttributionRecord(value, field) {
+    const record = exact(value, ['accountId', 'resourceId', 'resourceName', 'resourceType', 'benefitIds', 'windowStart', 'windowEnd', 'coveredCost'], field);
+    requiredString(record.accountId, `${field}.accountId`);
+    requiredString(record.resourceId, `${field}.resourceId`);
+    optionalString(record.resourceName, `${field}.resourceName`);
+    optionalString(record.resourceType, `${field}.resourceType`);
+    strings(record.benefitIds, `${field}.benefitIds`);
+    requiredString(record.windowStart, `${field}.windowStart`);
+    requiredString(record.windowEnd, `${field}.windowEnd`);
+    optionalRecord(record.coveredCost, `${field}.coveredCost`, validateMoney);
+}
+function validateShape(value, field) {
+    const shape = exact(value, [
+        'provider',
+        'resourceType',
+        'commitmentFamily',
+        'skuName',
+        'normalizedSkuName',
+        'location',
+        'region',
+        'availabilityZone',
+        'platform',
+        'reservationProductName',
+        'reservedResourceType',
+        'meterCategory',
+        'meterSubCategory',
+        'meterName',
+        'unit',
+        'attributes',
+    ], field);
+    assertValue(shape.provider, 'aws', `${field}.provider`);
+    if (shape.attributes !== undefined)
+        asRecord(shape.attributes, `${field}.attributes`);
+}
+function validateSource(value, field, allowDerived) {
+    const source = exact(value, ['sourceKind', 'sourceId', 'sourceName', 'generatedAt', 'observedAt', 'notes'], field);
+    requiredEnum(source.sourceKind, allowDerived ? ['aws-native', 'spotto-derived'] : ['aws-native'], `${field}.sourceKind`);
+    optionalString(source.sourceId, `${field}.sourceId`);
+    optionalString(source.sourceName, `${field}.sourceName`);
+    optionalTimestamp(source.generatedAt, `${field}.generatedAt`);
+    optionalTimestamp(source.observedAt, `${field}.observedAt`);
+    optionalStrings(source.notes, `${field}.notes`);
+}
+function validateMoney(value, field) {
+    const money = exact(value, ['amount', 'currency', 'source', 'windowStart', 'windowEnd', 'flags'], field);
+    finiteNumber(money.amount, `${field}.amount`);
+    requiredString(money.currency, `${field}.currency`);
+    optionalString(money.source, `${field}.source`);
+    optionalString(money.windowStart, `${field}.windowStart`);
+    optionalString(money.windowEnd, `${field}.windowEnd`);
+    optionalStrings(money.flags, `${field}.flags`);
+}
+function validateUtilization(value, field) {
+    const utilization = exact(value, ['trend', 'oneDay', 'sevenDay', 'thirtyDay', 'source'], field);
+    optionalString(utilization.trend, `${field}.trend`);
+    optionalNumber(utilization.oneDay, `${field}.oneDay`);
+    optionalNumber(utilization.sevenDay, `${field}.sevenDay`);
+    optionalNumber(utilization.thirtyDay, `${field}.thirtyDay`);
+    optionalString(utilization.source, `${field}.source`);
+}
+function validatePricingContext(value, field) {
+    const pricing = exact(value, ['source', 'currency', 'assumptions', 'confidenceNotes', 'calculatorDeepLink'], field);
+    requiredEnum(pricing.source, ['retail', 'negotiated', 'unknown', 'recommendation-apis'], `${field}.source`);
+    optionalString(pricing.currency, `${field}.currency`);
+    optionalStrings(pricing.assumptions, `${field}.assumptions`);
+    optionalString(pricing.confidenceNotes, `${field}.confidenceNotes`);
+    optionalString(pricing.calculatorDeepLink, `${field}.calculatorDeepLink`);
+}
+function validateFreshness(value, field) {
+    const freshness = exact(value, ['status', 'generatedAt', 'entries', 'warnings'], field);
+    requiredEnum(freshness.status, ['current', 'stale', 'partial', 'unavailable'], `${field}.status`);
+    isoTimestamp(freshness.generatedAt, `${field}.generatedAt`);
+    records(freshness.entries, `${field}.entries`, (entry, itemField) => {
+        const item = exact(entry, ['section', 'status', 'generatedAt', 'observedAt', 'lastSuccessfulSyncAt', 'reason', 'sourceKind'], itemField);
+        requiredString(item.section, `${itemField}.section`);
+        requiredEnum(item.status, ['current', 'stale', 'partial', 'unavailable'], `${itemField}.status`);
+        optionalTimestamp(item.generatedAt, `${itemField}.generatedAt`);
+        optionalTimestamp(item.observedAt, `${itemField}.observedAt`);
+        optionalTimestamp(item.lastSuccessfulSyncAt, `${itemField}.lastSuccessfulSyncAt`);
+        optionalString(item.reason, `${itemField}.reason`);
+        optionalString(item.sourceKind, `${itemField}.sourceKind`);
+    });
+    optionalStrings(freshness.warnings, `${field}.warnings`);
+}
+function exact(value, allowed, field) {
+    const record = asRecord(value, field);
+    assertExactKeys(record, allowed, field);
+    return record;
+}
+function records(value, field, validate, nonEmpty = false) {
+    if (!Array.isArray(value) || (nonEmpty && value.length === 0)) {
+        throw new Error(`${field} must be ${nonEmpty ? 'a non-empty' : 'an'} array.`);
+    }
+    value.forEach((entry, index) => validate(entry, `${field}[${index}]`));
+}
+function optionalRecords(value, field, validate) {
+    if (value !== undefined)
+        records(value, field, validate);
+}
+function optionalRecord(value, field, validate) {
+    if (value !== undefined)
+        validate(value, field);
+}
+function strings(value, field) {
+    if (!Array.isArray(value))
+        throw new Error(`${field} must be an array.`);
+    value.forEach((entry, index) => requiredString(entry, `${field}[${index}]`));
+}
+function optionalStrings(value, field) {
+    if (value !== undefined)
+        strings(value, field);
+}
+function optionalString(value, field) {
+    if (value !== undefined)
+        requiredString(value, field);
+}
+function optionalTimestamp(value, field) {
+    if (value !== undefined)
+        isoTimestamp(value, field);
+}
+function optionalNumber(value, field) {
+    if (value !== undefined)
+        finiteNumber(value, field);
+}
+function nonNegative(value, field) {
+    const number = finiteNumber(value, field);
+    if (number < 0)
+        throw new Error(`${field} must not be negative.`);
+}

package/dist/esm/aws/portalOrganizationCommitmentsPlanningPublicArtifacts.js

@@ -0,0 +1,2 @@
+export const AWS_ORGANIZATION_COMMITMENTS_PUBLIC_ARTIFACT_SCHEMA_VERSION = 1;
+export const AWS_ORGANIZATION_COMMITMENTS_PLANNING_LOGICAL_NAME = 'organization-commitments-planning.json.gz';

package/dist/esm/aws/requests.js

@@ -3,7 +3,7 @@ export const AWS_COMMAND_SCHEMA_VERSION = 1;
 /** Canonical provider wire value for AWS commands. */
 export const AWS_COMMAND_PROVIDER = 'aws';
 /** Entities handled by AWS estate orchestration. */
-export const AWS_COMMAND_ENTITIES = ['estate', 'account', 'billing-source'];
+export const AWS_COMMAND_ENTITIES = ['estate', 'account', 'billing-source', 'organization-commitments'];
 /** Actions supported across AWS estate orchestration commands. */
 export const AWS_COMMAND_ACTIONS = ['reconcile', 'refresh', 'delete'];
 /** Credential-shaped keys forbidden from shared AWS configuration and commands. */

package/dist/esm/azure/financialAnalyticsDelivery.js

@@ -1,7 +1,9 @@
 export const FINANCIAL_ANALYTICS_JOB_REQUEST_CONTRACT_VERSION_V1 = 'financial-analytics-job-request/v1';
 export const FINANCIAL_ANALYTICS_CURRENT_POINTER_CONTRACT_VERSION_V1 = 'financial-analytics-current-pointer/v1';
 export const FINANCIAL_ANALYTICS_INPUT_LOGICAL_NAME_V1 = 'financial-analytics-input.json.gz';
+export const FINANCIAL_ANALYTICS_INPUT_BY_ID_ROOT_V1 = 'financial-analytics/inputs-by-id';
 export const FINANCIAL_ANALYTICS_PROJECTION_LOGICAL_NAME_V1 = 'financial-analytics-projection.json.gz';
 export const FINANCIAL_ANALYTICS_BATCH_QUERY_CONTRACT_VERSION_V1 = 'financial-analytics-batch-query/v1';
 export const FINANCIAL_ANALYTICS_BATCH_RESPONSE_CONTRACT_VERSION_V1 = 'financial-analytics-batch-response/v1';
 export const FINANCIAL_ANALYTICS_OUTPUT_MANIFEST_CONTRACT_VERSION_V1 = 'financial-analytics-output-manifest/v1';
+export const financialAnalyticsInputByIdPathV1 = (analyticsInputId) => `${FINANCIAL_ANALYTICS_INPUT_BY_ID_ROOT_V1}/${analyticsInputId}/${FINANCIAL_ANALYTICS_INPUT_LOGICAL_NAME_V1}`;

package/dist/esm/azure/financialAnalyticsDisplayKernel.js

@@ -0,0 +1,139 @@
+import { formatExactDecimalValue, parseCanonicalDecimal, sumCanonicalDecimals } from '../common/exactDecimal.js';
+import { isFinancialAnalyticsInputSeriesV1 } from './financialAnalyticsValidation.js';
+const DAY_MS = 86400000;
+const HISTORY_NOT_PRODUCED = 'history-not-produced';
+const CALENDAR_PERIOD_INCOMPLETE = 'calendar-period-incomplete';
+const addUtcDays = (date, days) => new Date(Date.parse(`${date}T00:00:00.000Z`) + days * DAY_MS).toISOString().slice(0, 10);
+const shiftUtcMonths = (date, months) => {
+    const parsed = new Date(`${date}T00:00:00.000Z`);
+    return new Date(Date.UTC(parsed.getUTCFullYear(), parsed.getUTCMonth() + months, 1)).toISOString().slice(0, 10);
+};
+const uniqueReasons = (values) => {
+    const reasons = [...new Set(values)].sort();
+    return (reasons.length > 0 ? reasons : [HISTORY_NOT_PRODUCED]);
+};
+/** Twelve-decimal half-away-from-zero display average; totals remain exact. */
+const averageKnownPerDay = (amount, dayCount) => {
+    if (!Number.isSafeInteger(dayCount) || dayCount < 1)
+        throw new RangeError('Display average requires a positive day count.');
+    const value = parseCanonicalDecimal(amount);
+    const precision = 12;
+    const numerator = (value.coefficient < 0n ? -value.coefficient : value.coefficient) * 10n ** BigInt(precision);
+    const scaledDivisor = BigInt(dayCount) * 10n ** BigInt(value.scale);
+    let quotient = numerator / scaledDivisor;
+    const remainder = numerator % scaledDivisor;
+    if (remainder * 2n >= scaledDivisor)
+        quotient += 1n;
+    return formatExactDecimalValue({ coefficient: value.coefficient < 0n ? -quotient : quotient, scale: precision });
+};
+const requestedInterval = (input, periodKey) => {
+    const endDateExclusive = input.coordinate.period.requested.endDateExclusive;
+    const startDate = periodKey === 'last-7-days'
+        ? addUtcDays(endDateExclusive, -7)
+        : periodKey === 'rolling-30-days'
+            ? addUtcDays(endDateExclusive, -30)
+            : periodKey === 'rolling-90-days'
+                ? addUtcDays(endDateExclusive, -90)
+                : shiftUtcMonths(addUtcDays(endDateExclusive, -1), -11);
+    return {
+        startDate,
+        endDateExclusive,
+        dateBasis: input.coordinate.period.requested.dateBasis,
+        ...(input.coordinate.period.requested.timeZone === undefined
+            ? {}
+            : { timeZone: input.coordinate.period.requested.timeZone }),
+    };
+};
+const displayDays = (input, startDate, endDateExclusive) => {
+    const pointByDate = new Map(input.points.map(point => [point.date, point]));
+    const gapReasons = (date) => input.gaps
+        .filter(gap => gap.startDate <= date && gap.endDateExclusive > date)
+        .flatMap(gap => gap.reasonCodes);
+    const days = [];
+    for (let date = startDate; date < endDateExclusive; date = addUtcDays(date, 1)) {
+        const point = pointByDate.get(date);
+        if (point?.status === 'available') {
+            days.push({ date, status: 'available', knownAmount: point.amount, reasonCodes: [] });
+        }
+        else if (point?.status === 'partial') {
+            days.push({ date, status: 'partial', knownAmount: point.knownAmount, reasonCodes: point.reasonCodes });
+        }
+        else {
+            const reasons = gapReasons(date);
+            days.push({ date, status: 'unavailable', reasonCodes: reasons.length > 0 ? reasons : [HISTORY_NOT_PRODUCED] });
+        }
+    }
+    return days;
+};
+const toBucket = (bucketKey, startDate, endDateExclusive, days) => {
+    const knownAmounts = days.flatMap(day => (day.knownAmount === undefined ? [] : [day.knownAmount]));
+    const coversWholeBucket = days[0]?.date === startDate && days.length > 0 && addUtcDays(days[days.length - 1].date, 1) === endDateExclusive;
+    const reasonCodes = uniqueReasons([
+        ...days.flatMap(day => day.reasonCodes),
+        ...(coversWholeBucket ? [] : [CALENDAR_PERIOD_INCOMPLETE]),
+    ]);
+    if (knownAmounts.length === 0) {
+        return { bucketKey, startDate, endDateExclusive, status: 'unavailable', reasonCodes };
+    }
+    const knownAmount = formatExactDecimalValue(sumCanonicalDecimals(knownAmounts));
+    const average = averageKnownPerDay(knownAmount, knownAmounts.length);
+    if (coversWholeBucket && days.every(day => day.status === 'available')) {
+        return { bucketKey, startDate, endDateExclusive, status: 'available', amount: knownAmount, averageKnownPerDay: average };
+    }
+    return { bucketKey, startDate, endDateExclusive, status: 'partial', knownAmount, averageKnownPerDay: average, reasonCodes };
+};
+const dailyBuckets = (days) => days.map(day => toBucket(day.date, day.date, addUtcDays(day.date, 1), [day]));
+const monthlyBuckets = (days) => {
+    const byMonth = new Map();
+    days.forEach(day => {
+        const month = day.date.slice(0, 7);
+        byMonth.set(month, [...(byMonth.get(month) ?? []), day]);
+    });
+    return [...byMonth.entries()].map(([month, monthDays]) => toBucket(month, `${month}-01`, shiftUtcMonths(`${month}-01`, 1), monthDays));
+};
+/**
+ * Exact, non-authoritative display rollup over one producer-owned analytics
+ * input. The function never changes charge inclusion, estimates, cost basis,
+ * currency, or source evidence; uncovered dates remain explicit.
+ */
+export const projectFinancialAnalyticsDisplayPeriodV1 = (request) => {
+    if (!isFinancialAnalyticsInputSeriesV1(request.input)) {
+        throw new TypeError('Financial analytics display projection requires a valid input series.');
+    }
+    const current = request.input.referenceCompositions.find(composition => composition.coordinate.periodRole === 'current-spend' && composition.compositionId === request.currentSpendCompositionId);
+    if (!current) {
+        throw new TypeError('Financial analytics input does not bind the requested current-spend composition.');
+    }
+    const accountingCurrency = request.input.coordinate.accountingCurrency;
+    if (accountingCurrency.status !== 'resolved') {
+        throw new TypeError('Financial analytics display projection requires a resolved accounting currency.');
+    }
+    const requested = requestedInterval(request.input, request.periodKey);
+    const days = displayDays(request.input, requested.startDate, requested.endDateExclusive);
+    const buckets = request.periodKey === 'trailing-12-calendar-months' ? monthlyBuckets(days) : dailyBuckets(days);
+    const common = {
+        analyticsInputId: request.input.analyticsInputId,
+        currentSpendCompositionId: current.compositionId,
+        chargeInclusionPolicyRef: current.coordinate.chargeInclusionPolicyRef,
+        periodKey: request.periodKey,
+        requested,
+        bucketGranularity: request.periodKey === 'trailing-12-calendar-months' ? 'calendar-month' : 'daily',
+        currencyCode: accountingCurrency.currencyCode,
+        buckets,
+    };
+    const knownAmounts = days.flatMap(day => (day.knownAmount === undefined ? [] : [day.knownAmount]));
+    const calendarPeriodIncomplete = request.periodKey === 'trailing-12-calendar-months' &&
+        requested.endDateExclusive !== shiftUtcMonths(addUtcDays(requested.endDateExclusive, -1), 1);
+    const reasonCodes = uniqueReasons([
+        ...days.flatMap(day => day.reasonCodes),
+        ...(calendarPeriodIncomplete ? [CALENDAR_PERIOD_INCOMPLETE] : []),
+    ]);
+    if (knownAmounts.length === 0)
+        return { ...common, status: 'unavailable', reasonCodes };
+    const knownAmount = formatExactDecimalValue(sumCanonicalDecimals(knownAmounts));
+    const average = averageKnownPerDay(knownAmount, knownAmounts.length);
+    if (!calendarPeriodIncomplete && days.every(day => day.status === 'available')) {
+        return { ...common, status: 'available', amount: knownAmount, averageKnownPerDay: average };
+    }
+    return { ...common, status: 'partial', knownAmount, averageKnownPerDay: average, reasonCodes };
+};