@spottoai/types-package 1.0.2-beta.98 → 1.0.2-dev1138.1

package/dist/esm/azure/financialSavingsCoordinateValidation.js

@@ -0,0 +1,329 @@
+import { sha256Utf8 } from '../common/sha256.js';
+import { canonicalizeFinancialSavingsJsonValue, hasExactFinancialSavingsFields, haveSameFinancialSavingsSet, isFinancialSavingsHash, isFinancialSavingsIdentity, isFinancialSavingsIsoInstant, isFinancialSavingsMinorUnits, isFinancialSavingsRecord, sumFinancialSavingsMinorUnits, } from './financialSavingsAuthorityValidationPrimitives.js';
+const CURRENCY = /^[A-Z]{3}$/;
+const UNAVAILABLE_REASONS = new Set([
+    'scenario-coverage-unproven',
+    'unmigrated-scenario-producer',
+    'projection-unavailable',
+    'activation-unavailable',
+    'allocation-unavailable',
+]);
+const LIFECYCLE_STATES = new Set(['Active', 'Prioritized', 'Dismissed', 'Archived', 'Implementing', 'Implemented', 'Failed', 'Unrecognized']);
+const ACTIVATION_REASONS = new Set([
+    'active',
+    'prioritized',
+    'dismissal-expired',
+    'implementing',
+    'failed',
+    'archived',
+    'implemented',
+    'dismissed-active',
+    'lifecycle-stale',
+    'lifecycle-unavailable',
+    'lifecycle-conflict',
+    'unrecognized-lifecycle',
+    'generation-mismatch',
+]);
+const UNAVAILABLE_ACTIVATION_REASONS = new Set(['lifecycle-stale', 'lifecycle-unavailable', 'lifecycle-conflict', 'generation-mismatch']);
+export const canonicalizeFinancialSavingsDenominatorIdentityV1 = (value) => JSON.stringify(canonicalizeFinancialSavingsJsonValue({
+    kind: value.kind,
+    baselineId: value.baselineId,
+    componentIds: [...value.componentIds].sort(),
+    amount: value.amount,
+    currencyCode: value.currencyCode,
+}));
+export const createFinancialSavingsDenominatorIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialSavingsDenominatorIdentityV1(value))}`;
+export const canonicalizeFinancialSavingsActivationIdentityV1 = (value) => JSON.stringify(canonicalizeFinancialSavingsJsonValue({
+    recommendationId: value.recommendationId,
+    projectionId: value.projectionId,
+    lifecycleState: value.lifecycleState,
+    lifecycleVersion: value.lifecycleVersion,
+    lifecycleEvidenceRefId: value.lifecycleEvidenceRefId,
+    result: value.result,
+    reason: value.reason,
+    evaluatedAt: value.evaluatedAt,
+    policyVersion: value.policyVersion,
+}));
+export const createFinancialSavingsActivationIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialSavingsActivationIdentityV1(value))}`;
+export const canonicalizeFinancialSavingsAllocationIdentityV1 = (value) => JSON.stringify(canonicalizeFinancialSavingsJsonValue({
+    ownerScopeId: value.ownerScopeId,
+    billableComponentIds: [...value.billableComponentIds].sort(),
+    recommendationId: value.recommendationId,
+    baselineId: value.baselineId,
+    projectionId: value.projectionId,
+    denominatorId: value.denominatorId,
+    eligibility: value.eligibility.kind === 'not-applicable'
+        ? value.eligibility
+        : {
+            ...value.eligibility,
+            currentComponentIds: [...value.eligibility.currentComponentIds].sort(),
+            eligibilityComponentIds: [...value.eligibility.eligibilityComponentIds].sort(),
+        },
+    activationId: value.activationId,
+    savingsMinorUnits: value.savingsMinorUnits,
+}));
+export const createFinancialSavingsAllocationIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialSavingsAllocationIdentityV1(value))}`;
+const decimalToMinorUnits = (value, scale) => {
+    const match = /^([0-9]+)(?:\.([0-9]+))?$/.exec(value);
+    if (!match)
+        return undefined;
+    const fraction = match[2] ?? '';
+    const kept = fraction.slice(0, scale).padEnd(scale, '0');
+    const discarded = fraction.slice(scale);
+    let units = BigInt(match[1]) * 10n ** BigInt(scale) + BigInt(kept || '0');
+    if (discarded[0] !== undefined && discarded[0] >= '5')
+        units += 1n;
+    return units <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(units) : undefined;
+};
+const isActivationDecision = (state, result, reason) => {
+    if (typeof state !== 'string' || !LIFECYCLE_STATES.has(state) || typeof reason !== 'string' || !ACTIVATION_REASONS.has(reason)) {
+        return false;
+    }
+    if (result === 'included') {
+        return ((state === 'Active' && reason === 'active') ||
+            (state === 'Prioritized' && reason === 'prioritized') ||
+            (state === 'Dismissed' && reason === 'dismissal-expired') ||
+            (state === 'Implementing' && reason === 'implementing') ||
+            (state === 'Failed' && reason === 'failed'));
+    }
+    if (result === 'excluded') {
+        return ((state === 'Archived' && reason === 'archived') ||
+            (state === 'Implemented' && reason === 'implemented') ||
+            (state === 'Dismissed' && reason === 'dismissed-active'));
+    }
+    if (result !== 'unavailable')
+        return false;
+    if (state === 'Unrecognized')
+        return reason === 'unrecognized-lifecycle';
+    return UNAVAILABLE_ACTIVATION_REASONS.has(reason);
+};
+const isEligibility = (value) => {
+    if (!isFinancialSavingsRecord(value) || (value.kind !== 'not-applicable' && value.kind !== 'mapped'))
+        return false;
+    if (value.kind === 'not-applicable')
+        return Object.keys(value).length === 1;
+    return (Object.keys(value).length === 5 &&
+        isFinancialSavingsHash(value.eligibilityId) &&
+        isFinancialSavingsHash(value.eligibilityBaselineId) &&
+        Array.isArray(value.currentComponentIds) &&
+        value.currentComponentIds.length > 0 &&
+        value.currentComponentIds.every(isFinancialSavingsIdentity) &&
+        new Set(value.currentComponentIds).size === value.currentComponentIds.length &&
+        Array.isArray(value.eligibilityComponentIds) &&
+        value.eligibilityComponentIds.length > 0 &&
+        value.eligibilityComponentIds.every(isFinancialSavingsIdentity) &&
+        new Set(value.eligibilityComponentIds).size === value.eligibilityComponentIds.length);
+};
+const validateAvailableCoordinate = (value, authorityCoordinate, eligibilityById, evidenceById, authorityGeneratedAt, authorityRunId) => {
+    if (!hasExactFinancialSavingsFields(value, [
+        'status',
+        'coordinateId',
+        'currentAggregateBaselineId',
+        'accountingCurrencyCode',
+        'minorUnitScale',
+        'roundingMode',
+        'scenarioCoverage',
+        'activations',
+        'allocations',
+        'resourceContributions',
+        'aggregate',
+    ]) ||
+        !isFinancialSavingsHash(value.currentAggregateBaselineId) ||
+        authorityCoordinate.aggregateBaseline.status !== 'available' ||
+        value.currentAggregateBaselineId !== authorityCoordinate.aggregateBaseline.baselineId ||
+        !CURRENCY.test(value.accountingCurrencyCode) ||
+        value.accountingCurrencyCode !== authorityCoordinate.aggregateBaseline.total.currencyCode ||
+        !Number.isSafeInteger(value.minorUnitScale) ||
+        value.minorUnitScale < 0 ||
+        value.minorUnitScale > 6 ||
+        value.roundingMode !== 'half-away-from-zero' ||
+        !isFinancialSavingsRecord(value.scenarioCoverage) ||
+        !hasExactFinancialSavingsFields(value.scenarioCoverage, ['status', 'evidenceRefId', 'scenarioIds']) ||
+        value.scenarioCoverage.status !== 'complete' ||
+        !isFinancialSavingsHash(value.scenarioCoverage.evidenceRefId) ||
+        !Array.isArray(value.scenarioCoverage.scenarioIds) ||
+        value.scenarioCoverage.scenarioIds.length > 20000 ||
+        !value.scenarioCoverage.scenarioIds.every(isFinancialSavingsIdentity) ||
+        new Set(value.scenarioCoverage.scenarioIds).size !== value.scenarioCoverage.scenarioIds.length ||
+        !Array.isArray(value.activations) ||
+        value.activations.length > 20000 ||
+        !Array.isArray(value.allocations) ||
+        value.allocations.length > 20000 ||
+        !Array.isArray(value.resourceContributions) ||
+        value.resourceContributions.length > 20000 ||
+        !isFinancialSavingsRecord(value.aggregate) ||
+        !hasExactFinancialSavingsFields(value.aggregate, ['allocationIds', 'savingsMinorUnits']) ||
+        !Array.isArray(value.aggregate.allocationIds) ||
+        value.aggregate.allocationIds.length > 20000 ||
+        !isFinancialSavingsMinorUnits(value.aggregate.savingsMinorUnits))
+        return false;
+    const scenarioCoverageEvidence = evidenceById.get(value.scenarioCoverage.evidenceRefId);
+    if (scenarioCoverageEvidence?.role !== 'recommendation-scenario-set' ||
+        scenarioCoverageEvidence.generationId !== authorityRunId ||
+        Date.parse(scenarioCoverageEvidence.intrinsicTime.at) > Date.parse(authorityGeneratedAt))
+        return false;
+    const projectionById = new Map(authorityCoordinate.projections.flatMap(projection => (projection.status === 'available' ? [[projection.projectionId, projection]] : [])));
+    const activationById = new Map();
+    const activationByRecommendationId = new Map();
+    for (const activation of value.activations) {
+        const lifecycleEvidence = evidenceById.get(activation.lifecycleEvidenceRefId);
+        if (!isFinancialSavingsRecord(activation) ||
+            !hasExactFinancialSavingsFields(activation, [
+                'activationId',
+                'recommendationId',
+                'projectionId',
+                'lifecycleState',
+                'lifecycleVersion',
+                'lifecycleEvidenceRefId',
+                'result',
+                'reason',
+                'evaluatedAt',
+                'policyVersion',
+            ]) ||
+            !isFinancialSavingsHash(activation.activationId) ||
+            activationById.has(activation.activationId) ||
+            activationByRecommendationId.has(activation.recommendationId) ||
+            !isFinancialSavingsIdentity(activation.recommendationId) ||
+            !isFinancialSavingsHash(activation.projectionId) ||
+            !isFinancialSavingsIdentity(activation.lifecycleVersion) ||
+            !isFinancialSavingsHash(activation.lifecycleEvidenceRefId) ||
+            !isActivationDecision(activation.lifecycleState, activation.result, activation.reason) ||
+            !isFinancialSavingsIsoInstant(activation.evaluatedAt) ||
+            Date.parse(activation.evaluatedAt) > Date.parse(authorityGeneratedAt) ||
+            !isFinancialSavingsIdentity(activation.policyVersion) ||
+            projectionById.get(activation.projectionId)?.scenarioId !== activation.recommendationId ||
+            lifecycleEvidence?.role !== 'recommendation-lifecycle' ||
+            lifecycleEvidence.revisionId !== activation.lifecycleVersion ||
+            Date.parse(lifecycleEvidence.intrinsicTime.at) > Date.parse(authorityGeneratedAt))
+            return false;
+        const { activationId: _activationId, ...activationIdentity } = activation;
+        if (activation.activationId !== createFinancialSavingsActivationIdV1(activationIdentity))
+            return false;
+        activationById.set(activation.activationId, activation);
+        activationByRecommendationId.set(activation.recommendationId, activation);
+    }
+    const coveredScenarioIds = new Set(value.scenarioCoverage.scenarioIds);
+    const activatedScenarioIds = new Set(value.activations.map(activation => activation.recommendationId));
+    if (value.scenarioCoverage.scenarioIds.some(scenarioId => !activatedScenarioIds.has(scenarioId)) ||
+        value.activations.some(activation => !coveredScenarioIds.has(activation.recommendationId)))
+        return false;
+    const allocationById = new Map();
+    const allocatedBaselineComponents = new Set();
+    for (const allocation of value.allocations) {
+        const projection = projectionById.get(allocation.projectionId);
+        const activation = activationById.get(allocation.activationId);
+        const eligibility = allocation.eligibility.kind === 'mapped' ? eligibilityById.get(allocation.eligibility.eligibilityId) : undefined;
+        const expectedDenominatorId = allocation.eligibility.kind === 'mapped' && eligibility?.status === 'available'
+            ? eligibility.denominator.denominatorId
+            : projection
+                ? createFinancialSavingsDenominatorIdV1({
+                    kind: 'projection-affected-current',
+                    baselineId: projection.baselineId,
+                    componentIds: projection.affectedComponentIds,
+                    amount: projection.current.affected,
+                    currencyCode: projection.accountingCurrencyCode,
+                })
+                : undefined;
+        if (!isFinancialSavingsRecord(allocation) ||
+            !hasExactFinancialSavingsFields(allocation, [
+                'allocationId',
+                'ownerScopeId',
+                'billableComponentIds',
+                'recommendationId',
+                'baselineId',
+                'projectionId',
+                'denominatorId',
+                'eligibility',
+                'activationId',
+                'savingsMinorUnits',
+            ]) ||
+            !isFinancialSavingsHash(allocation.allocationId) ||
+            allocationById.has(allocation.allocationId) ||
+            !isFinancialSavingsIdentity(allocation.ownerScopeId) ||
+            !Array.isArray(allocation.billableComponentIds) ||
+            allocation.billableComponentIds.length === 0 ||
+            allocation.billableComponentIds.length > 20000 ||
+            !allocation.billableComponentIds.every(isFinancialSavingsIdentity) ||
+            new Set(allocation.billableComponentIds).size !== allocation.billableComponentIds.length ||
+            !isFinancialSavingsIdentity(allocation.recommendationId) ||
+            !isFinancialSavingsHash(allocation.baselineId) ||
+            !isFinancialSavingsHash(allocation.projectionId) ||
+            !isFinancialSavingsHash(allocation.denominatorId) ||
+            allocation.denominatorId !== expectedDenominatorId ||
+            !isEligibility(allocation.eligibility) ||
+            !isFinancialSavingsHash(allocation.activationId) ||
+            !isFinancialSavingsMinorUnits(allocation.savingsMinorUnits) ||
+            !projection ||
+            projection.scopeId !== allocation.ownerScopeId ||
+            projection.baselineId !== allocation.baselineId ||
+            !haveSameFinancialSavingsSet(projection.affectedComponentIds, allocation.billableComponentIds) ||
+            decimalToMinorUnits(projection.change.savings, value.minorUnitScale) !== allocation.savingsMinorUnits ||
+            !activation ||
+            activation.result !== 'included' ||
+            activation.recommendationId !== allocation.recommendationId ||
+            activation.projectionId !== allocation.projectionId ||
+            (allocation.eligibility.kind === 'mapped' &&
+                (!eligibility ||
+                    eligibility.status !== 'available' ||
+                    eligibility.scopeId !== allocation.ownerScopeId ||
+                    eligibility.scenarioId !== allocation.recommendationId ||
+                    eligibility.eligibilityBaselineId !== allocation.eligibility.eligibilityBaselineId ||
+                    eligibility.denominator.denominatorId !== allocation.denominatorId ||
+                    eligibility.currentBaselineMapping.currentBaselineId !== allocation.baselineId ||
+                    !haveSameFinancialSavingsSet(allocation.eligibility.currentComponentIds, allocation.billableComponentIds) ||
+                    !haveSameFinancialSavingsSet(allocation.eligibility.currentComponentIds, eligibility.currentBaselineMapping.mappings.map(mapping => mapping.currentComponentId)) ||
+                    !haveSameFinancialSavingsSet(allocation.eligibility.eligibilityComponentIds, eligibility.eligibleComponentIds))))
+            return false;
+        const { allocationId: _allocationId, ...allocationIdentity } = allocation;
+        if (allocation.allocationId !== createFinancialSavingsAllocationIdV1(allocationIdentity))
+            return false;
+        for (const componentId of allocation.billableComponentIds) {
+            const componentKey = `${allocation.baselineId}\u0000${componentId}`;
+            if (allocatedBaselineComponents.has(componentKey))
+                return false;
+            allocatedBaselineComponents.add(componentKey);
+        }
+        allocationById.set(allocation.allocationId, allocation);
+    }
+    const contributedAllocationIds = [];
+    const ownerScopeIds = new Set();
+    for (const contribution of value.resourceContributions) {
+        if (!isFinancialSavingsRecord(contribution) ||
+            !hasExactFinancialSavingsFields(contribution, ['ownerScopeId', 'allocationIds', 'savingsMinorUnits']) ||
+            !isFinancialSavingsIdentity(contribution.ownerScopeId) ||
+            ownerScopeIds.has(contribution.ownerScopeId) ||
+            !Array.isArray(contribution.allocationIds) ||
+            contribution.allocationIds.length === 0 ||
+            contribution.allocationIds.length > 20000 ||
+            !contribution.allocationIds.every(isFinancialSavingsHash) ||
+            new Set(contribution.allocationIds).size !== contribution.allocationIds.length ||
+            !isFinancialSavingsMinorUnits(contribution.savingsMinorUnits))
+            return false;
+        const allocations = contribution.allocationIds.map(id => allocationById.get(id));
+        if (allocations.some(allocation => !allocation || allocation.ownerScopeId !== contribution.ownerScopeId) ||
+            sumFinancialSavingsMinorUnits(allocations.map(allocation => allocation.savingsMinorUnits)) !== contribution.savingsMinorUnits)
+            return false;
+        ownerScopeIds.add(contribution.ownerScopeId);
+        contributedAllocationIds.push(...contribution.allocationIds);
+    }
+    const allocationIds = [...allocationById.keys()];
+    return (haveSameFinancialSavingsSet(contributedAllocationIds, allocationIds) &&
+        new Set(contributedAllocationIds).size === contributedAllocationIds.length &&
+        haveSameFinancialSavingsSet(value.aggregate.allocationIds, allocationIds) &&
+        new Set(value.aggregate.allocationIds).size === value.aggregate.allocationIds.length &&
+        value.aggregate.savingsMinorUnits === sumFinancialSavingsMinorUnits(value.allocations.map(allocation => allocation.savingsMinorUnits)));
+};
+export const validateFinancialSavingsCoordinateEnvelopeV1 = (value, authorityCoordinate, eligibilityById, evidenceById, authorityGeneratedAt, authorityRunId) => {
+    if (!isFinancialSavingsRecord(value) || value.coordinateId !== authorityCoordinate.coordinateId)
+        return false;
+    if (value.status === 'unavailable') {
+        return (hasExactFinancialSavingsFields(value, ['status', 'coordinateId', 'unavailableReason'], ['currentAggregateBaselineId']) &&
+            typeof value.unavailableReason === 'string' &&
+            UNAVAILABLE_REASONS.has(value.unavailableReason) &&
+            (authorityCoordinate.aggregateBaseline.status === 'available'
+                ? value.currentAggregateBaselineId === authorityCoordinate.aggregateBaseline.baselineId
+                : value.currentAggregateBaselineId === undefined));
+    }
+    return (value.status === 'available' &&
+        validateAvailableCoordinate(value, authorityCoordinate, eligibilityById, evidenceById, authorityGeneratedAt, authorityRunId));
+};

package/dist/esm/azure/financialSavingsSurfaceProjection.js

@@ -0,0 +1,2 @@
+export const FINANCIAL_SAVINGS_SURFACE_PROJECTION_SCHEMA_VERSION_V1 = 1;
+export const FINANCIAL_SAVINGS_SURFACE_PROJECTION_CONTRACT_VERSION_V1 = 'financial-savings-surface-projection/v1';

package/dist/esm/azure/financialSavingsSurfaceProjectionValidation.js

@@ -0,0 +1,171 @@
+import { sha256Utf8 } from '../common/sha256.js';
+import { canonicalizeFinancialSavingsJsonValue, hasExactFinancialSavingsFields, haveSameFinancialSavingsSet, isFinancialSavingsHash, isFinancialSavingsIdentity, isFinancialSavingsIsoInstant, isFinancialSavingsMinorUnits, isFinancialSavingsRecord, sumFinancialSavingsMinorUnits, } from './financialSavingsAuthorityValidationPrimitives.js';
+import { FINANCIAL_SAVINGS_SURFACE_PROJECTION_CONTRACT_VERSION_V1, FINANCIAL_SAVINGS_SURFACE_PROJECTION_SCHEMA_VERSION_V1, } from './financialSavingsSurfaceProjection.js';
+import { isFinancialBaselinePeriodV2 } from './financialScopeBaselineValidation.js';
+import { isCanonicalExactMoney } from './financialValidationPrimitives.js';
+const COST_BASES = new Set(['billed', 'amortized']);
+const ESTIMATE_LENSES = new Set(['actual-only', 'actual-plus-estimated', 'estimates-only']);
+const UNAVAILABLE_REASONS = new Set([
+    'scenario-coverage-unproven',
+    'unmigrated-scenario-producer',
+    'projection-unavailable',
+    'activation-unavailable',
+    'allocation-unavailable',
+]);
+const CURRENCY = /^[A-Z]{3}$/;
+const MAX_COORDINATES = 128;
+const MAX_ALLOCATIONS = 20000;
+export const canonicalizeFinancialSavingsSurfaceProjectionIdentityV1 = (value) => JSON.stringify(canonicalizeFinancialSavingsJsonValue({
+    ...value,
+    providerAccountRefs: [...value.providerAccountRefs].sort(),
+    scope: value.scope.kind === 'subscription-full' ? value.scope : { ...value.scope, recommendationIds: [...value.scope.recommendationIds].sort() },
+    coordinates: [...value.coordinates]
+        .sort((left, right) => left.coordinateId.localeCompare(right.coordinateId))
+        .map(coordinate => coordinate.status === 'unavailable'
+        ? coordinate
+        : {
+            ...coordinate,
+            recommendationContributions: [...coordinate.recommendationContributions]
+                .sort((left, right) => left.recommendationId.localeCompare(right.recommendationId))
+                .map(contribution => ({ ...contribution, allocationIds: [...contribution.allocationIds].sort() })),
+            aggregate: { ...coordinate.aggregate, allocationIds: [...coordinate.aggregate.allocationIds].sort() },
+        }),
+}));
+export const createFinancialSavingsSurfaceProjectionIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialSavingsSurfaceProjectionIdentityV1(value))}`;
+const isCurrency = (value) => typeof value === 'string' && CURRENCY.test(value);
+const isScope = (value) => {
+    if (!isFinancialSavingsRecord(value))
+        return false;
+    if (value.kind === 'subscription-full')
+        return hasExactFinancialSavingsFields(value, ['kind']);
+    return (value.kind === 'recommendation-query' &&
+        hasExactFinancialSavingsFields(value, ['kind', 'filterFingerprint', 'recommendationIds']) &&
+        isFinancialSavingsHash(value.filterFingerprint) &&
+        Array.isArray(value.recommendationIds) &&
+        value.recommendationIds.length <= MAX_ALLOCATIONS &&
+        value.recommendationIds.every(isFinancialSavingsIdentity) &&
+        new Set(value.recommendationIds).size === value.recommendationIds.length);
+};
+const isCoordinateCommon = (value) => isFinancialSavingsHash(value.coordinateId) &&
+    (value.periodRole === 'current' || value.periodRole === 'previous') &&
+    isFinancialBaselinePeriodV2(value.period) &&
+    typeof value.costBasis === 'string' &&
+    COST_BASES.has(value.costBasis) &&
+    typeof value.estimateLens === 'string' &&
+    ESTIMATE_LENSES.has(value.estimateLens) &&
+    (value.requestedCurrencyCode === undefined || isCurrency(value.requestedCurrencyCode)) &&
+    (value.currentAggregateBaselineId === undefined || isFinancialSavingsHash(value.currentAggregateBaselineId));
+const isAvailableCoordinate = (value, queryRecommendationIds) => {
+    if (!hasExactFinancialSavingsFields(value, [
+        'status',
+        'coordinateId',
+        'periodRole',
+        'period',
+        'costBasis',
+        'estimateLens',
+        'currentAggregateBaselineId',
+        'currentAggregate',
+        'accountingCurrencyCode',
+        'minorUnitScale',
+        'roundingMode',
+        'recommendationContributions',
+        'aggregate',
+    ], ['requestedCurrencyCode']) ||
+        !isCoordinateCommon(value) ||
+        !isFinancialSavingsHash(value.currentAggregateBaselineId) ||
+        !isCanonicalExactMoney(value.currentAggregate) ||
+        !isCurrency(value.accountingCurrencyCode) ||
+        value.currentAggregate.currencyCode !== value.accountingCurrencyCode ||
+        !Number.isSafeInteger(value.minorUnitScale) ||
+        Number(value.minorUnitScale) < 0 ||
+        Number(value.minorUnitScale) > 6 ||
+        value.roundingMode !== 'half-away-from-zero' ||
+        !Array.isArray(value.recommendationContributions) ||
+        value.recommendationContributions.length > MAX_ALLOCATIONS ||
+        !isFinancialSavingsRecord(value.aggregate) ||
+        !hasExactFinancialSavingsFields(value.aggregate, ['allocationIds', 'savingsMinorUnits']) ||
+        !Array.isArray(value.aggregate.allocationIds) ||
+        value.aggregate.allocationIds.length > MAX_ALLOCATIONS ||
+        !value.aggregate.allocationIds.every(isFinancialSavingsHash) ||
+        new Set(value.aggregate.allocationIds).size !== value.aggregate.allocationIds.length ||
+        !isFinancialSavingsMinorUnits(value.aggregate.savingsMinorUnits))
+        return false;
+    const recommendationIds = new Set();
+    const allocationIds = [];
+    const contributionAmounts = [];
+    for (const contribution of value.recommendationContributions) {
+        if (!isFinancialSavingsRecord(contribution) ||
+            !hasExactFinancialSavingsFields(contribution, ['recommendationId', 'allocationIds', 'savingsMinorUnits']) ||
+            !isFinancialSavingsIdentity(contribution.recommendationId) ||
+            recommendationIds.has(contribution.recommendationId) ||
+            (queryRecommendationIds !== undefined && !queryRecommendationIds.has(contribution.recommendationId)) ||
+            !Array.isArray(contribution.allocationIds) ||
+            contribution.allocationIds.length === 0 ||
+            contribution.allocationIds.length > MAX_ALLOCATIONS ||
+            !contribution.allocationIds.every(isFinancialSavingsHash) ||
+            new Set(contribution.allocationIds).size !== contribution.allocationIds.length ||
+            !isFinancialSavingsMinorUnits(contribution.savingsMinorUnits))
+            return false;
+        recommendationIds.add(contribution.recommendationId);
+        allocationIds.push(...contribution.allocationIds);
+        contributionAmounts.push(contribution.savingsMinorUnits);
+    }
+    return (new Set(allocationIds).size === allocationIds.length &&
+        haveSameFinancialSavingsSet(allocationIds, value.aggregate.allocationIds) &&
+        sumFinancialSavingsMinorUnits(contributionAmounts) === value.aggregate.savingsMinorUnits);
+};
+const isUnavailableCoordinate = (value) => hasExactFinancialSavingsFields(value, ['status', 'coordinateId', 'periodRole', 'period', 'costBasis', 'estimateLens', 'unavailableReason'], ['requestedCurrencyCode', 'currentAggregateBaselineId']) &&
+    isCoordinateCommon(value) &&
+    typeof value.unavailableReason === 'string' &&
+    UNAVAILABLE_REASONS.has(value.unavailableReason);
+export const isFinancialSavingsSurfaceProjectionV1 = (value) => {
+    if (!isFinancialSavingsRecord(value) ||
+        !hasExactFinancialSavingsFields(value, [
+            'schemaVersion',
+            'contractVersion',
+            'projectionId',
+            'surface',
+            'scope',
+            'provider',
+            'providerAccountRefs',
+            'artifactGeneration',
+            'financialAuthorityId',
+            'savingsAuthorityId',
+            'coordinates',
+        ]) ||
+        value.schemaVersion !== FINANCIAL_SAVINGS_SURFACE_PROJECTION_SCHEMA_VERSION_V1 ||
+        value.contractVersion !== FINANCIAL_SAVINGS_SURFACE_PROJECTION_CONTRACT_VERSION_V1 ||
+        !isFinancialSavingsHash(value.projectionId) ||
+        (value.surface !== 'recommendations' && value.surface !== 'dashboard') ||
+        !isScope(value.scope) ||
+        (value.surface === 'dashboard' && value.scope.kind !== 'subscription-full') ||
+        value.provider !== 'azure' ||
+        !Array.isArray(value.providerAccountRefs) ||
+        value.providerAccountRefs.length === 0 ||
+        value.providerAccountRefs.length > 64 ||
+        !value.providerAccountRefs.every(isFinancialSavingsIdentity) ||
+        new Set(value.providerAccountRefs).size !== value.providerAccountRefs.length ||
+        !isFinancialSavingsRecord(value.artifactGeneration) ||
+        !hasExactFinancialSavingsFields(value.artifactGeneration, ['runId', 'generatedAt']) ||
+        !isFinancialSavingsIdentity(value.artifactGeneration.runId) ||
+        !isFinancialSavingsIsoInstant(value.artifactGeneration.generatedAt) ||
+        !isFinancialSavingsHash(value.financialAuthorityId) ||
+        !isFinancialSavingsHash(value.savingsAuthorityId) ||
+        !Array.isArray(value.coordinates) ||
+        value.coordinates.length === 0 ||
+        value.coordinates.length > MAX_COORDINATES)
+        return false;
+    const projection = value;
+    const queryRecommendationIds = projection.scope.kind === 'recommendation-query' ? new Set(projection.scope.recommendationIds) : undefined;
+    if (!projection.coordinates.every(coordinate => {
+        if (!isFinancialSavingsRecord(coordinate))
+            return false;
+        return coordinate.status === 'available'
+            ? isAvailableCoordinate(coordinate, queryRecommendationIds)
+            : coordinate.status === 'unavailable' && isUnavailableCoordinate(coordinate);
+    }) ||
+        new Set(projection.coordinates.map(coordinate => coordinate.coordinateId)).size !== projection.coordinates.length)
+        return false;
+    const { projectionId: _projectionId, ...identity } = projection;
+    return projection.projectionId === createFinancialSavingsSurfaceProjectionIdV1(identity);
+};

package/dist/esm/azure/financialScope.js

@@ -0,0 +1,25 @@
+export * from './financialScopeEvidence.js';
+export * from './financialScopeBaseline.js';
+export * from './financialScopeBaselineIdentity.js';
+export * from './financialScopeBaselineValidation.js';
+export * from './financialEvidenceAssessmentValidation.js';
+export * from './financialProjection.js';
+export * from './financialProjectionValidation.js';
+export * from './financialDisplayRollup.js';
+export * from './financialDisplayRollupValidation.js';
+export * from './financialAuthorityView.js';
+export * from './financialAuthorityViewValidation.js';
+export * from './financialSavingsAuthority.js';
+export * from './financialSavingsAuthorityValidation.js';
+export * from './financialSavingsSurfaceProjection.js';
+export * from './financialSavingsSurfaceProjectionValidation.js';
+export * from './financialDataflow.js';
+export * from './financialDataflowValidation.js';
+export * from './financialAnalytics.js';
+export * from './financialAnalyticsValidation.js';
+export * from './financialAnalyticsDelivery.js';
+export * from './financialAnalyticsDeliveryValidation.js';
+export * from './financialPolicy.js';
+export * from './financialPolicyValidation.js';
+export * from './financialPolicyDelivery.js';
+export * from './financialPolicyDeliveryValidation.js';

package/dist/esm/azure/financialScopeBaseline.js

@@ -0,0 +1,19 @@
+export const FINANCIAL_SCOPE_BASELINE_SCHEMA_VERSION_V2 = 2;
+export const FINANCIAL_SCOPE_BASELINE_CONTRACT_VERSION_V2 = 'financial-scope-baseline/v2';
+export const FINANCIAL_SCOPE_BASELINE_UNAVAILABLE_REASONS_V2 = [
+    'evidence-not-produced',
+    'evidence-not-matched',
+    'period-unresolved',
+    'coverage-incomplete',
+    'basis-unavailable',
+    'estimate-lens-unavailable',
+    'currency-unresolved',
+    'currency-conflicting',
+    'component-identity-unavailable',
+    'ownership-unresolved',
+    'ownership-conflict',
+    'mixed-generation',
+    'member-incompatible',
+    'reconciliation-failure',
+    'unsupported-scope',
+];