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

package/dist/esm/azure/financialAnalyticsValidation.js

@@ -6,7 +6,6 @@ import { FINANCIAL_DATAFLOW_LIMITS_V1, canonicalizeFinancialDataflowJsonV1, hasF
 import { isCurrentSpendCompositionV1 } from './financialDataflowValidation.js';
 const MAX_POINTS = 3660;
 const MAX_GAPS = 3660;
-const MAX_REFERENCE_COMPOSITIONS = 2;
 const isReasonCodes = (value) => Array.isArray(value) &&
     value.length > 0 &&
     value.length <= FINANCIAL_DATAFLOW_LIMITS_V1.maximumReasonCodes &&
@@ -30,7 +29,6 @@ const comparableCoordinate = (value) => ({
     estimateLens: value.estimateLens,
     requestedCurrencyCode: value.requestedCurrencyCode,
     accountingCurrency: value.accountingCurrency,
-    chargeInclusionPolicyRef: value.chargeInclusionPolicyRef,
 });
 const hasSameFinancialDimensions = (left, right) => canonicalizeFinancialDataflowJsonV1(comparableCoordinate(left)) === canonicalizeFinancialDataflowJsonV1(comparableCoordinate(right));
 const hasComparableTrendPeriods = (current, comparison) => {
@@ -44,10 +42,6 @@ const hasComparableTrendPeriods = (current, comparison) => {
     return (intervalDayCount(current.period.requested.startDate, current.period.requested.endDateExclusive) ===
         intervalDayCount(comparison.period.requested.startDate, comparison.period.requested.endDateExclusive));
 };
-const periodContains = (container, target) => container.period.requested.dateBasis === target.period.requested.dateBasis &&
-    container.period.requested.timeZone === target.period.requested.timeZone &&
-    container.period.requested.startDate <= target.period.requested.startDate &&
-    container.period.requested.endDateExclusive >= target.period.requested.endDateExclusive;
 const isInputIdentity = (value) => {
     if (!isFinancialDataflowRecordV1(value) ||
         !hasFinancialDataflowExactFieldsV1(value, [
@@ -56,7 +50,6 @@ const isInputIdentity = (value) => {
             'coordinate',
             'granularity',
             'producerGenerationId',
-            'referenceCompositions',
             'points',
             'gaps',
             'coverage',
@@ -66,12 +59,9 @@ const isInputIdentity = (value) => {
         value.contractVersion !== FINANCIAL_ANALYTICS_INPUT_CONTRACT_VERSION_V1 ||
         !isFinancialDataflowCoordinateV1(value.coordinate) ||
         value.coordinate.periodRole !== 'analytics-input' ||
-        value.coordinate.period.windowKind !== 'analytics-history' ||
         value.coordinate.accountingCurrency.status !== 'resolved' ||
         value.granularity !== 'daily' ||
         !isFinancialDataflowIdentityV1(value.producerGenerationId) ||
-        !Array.isArray(value.referenceCompositions) ||
-        value.referenceCompositions.length > MAX_REFERENCE_COMPOSITIONS ||
         !Array.isArray(value.points) ||
         value.points.length > MAX_POINTS ||
         !Array.isArray(value.gaps) ||
@@ -81,16 +71,6 @@ const isInputIdentity = (value) => {
         !isFinancialDataflowIdentityV1(value.algorithmVersion)) {
         return false;
     }
-    const coordinate = value.coordinate;
-    const referenceCompositions = value.referenceCompositions;
-    if (!referenceCompositions.every(isCurrentSpendCompositionV1))
-        return false;
-    const referenceRoles = referenceCompositions.map(composition => composition.coordinate.periodRole);
-    if (new Set(referenceCompositions.map(composition => composition.compositionId)).size !== referenceCompositions.length ||
-        new Set(referenceRoles).size !== referenceRoles.length ||
-        referenceCompositions.some(composition => !hasSameFinancialDimensions(coordinate, composition.coordinate))) {
-        return false;
-    }
     const gaps = value.gaps;
     const requested = value.coordinate.period.requested;
     const dates = new Set();
@@ -106,47 +86,16 @@ const isInputIdentity = (value) => {
             return false;
         }
         dates.add(point.date);
-        const pointForecastFields = [
-            point.forecastEligibleAmount,
-            point.oneTimeAmount,
-            point.unknownRecurrenceAmount,
-        ];
-        if (!pointForecastFields.every(amount => isCanonicalExactMoney({ amount, currencyCode: coordinate.accountingCurrency.currencyCode })) ||
-            (point.forecastStatus !== 'available' && point.forecastStatus !== 'partial') ||
-            (point.forecastStatus === 'available'
-                ? point.forecastReasonCodes !== undefined || point.unknownRecurrenceAmount !== '0'
-                : !isReasonCodes(point.forecastReasonCodes))) {
-            return false;
-        }
         if (point.status === 'available') {
-            if (!hasFinancialDataflowExactFieldsV1(point, [
-                'date',
-                'compositionId',
-                'status',
-                'amount',
-                'forecastEligibleAmount',
-                'oneTimeAmount',
-                'unknownRecurrenceAmount',
-                'forecastStatus',
-            ], ['forecastReasonCodes']) ||
-                !isCanonicalExactMoney({ amount: point.amount, currencyCode: coordinate.accountingCurrency.currencyCode }))
+            if (!hasFinancialDataflowExactFieldsV1(point, ['date', 'compositionId', 'status', 'amount']) ||
+                !isCanonicalExactMoney({ amount: point.amount, currencyCode: 'AUD' }))
                 return false;
             availableDayCount += 1;
         }
         else {
             if (point.status !== 'partial' ||
-                !hasFinancialDataflowExactFieldsV1(point, [
-                    'date',
-                    'compositionId',
-                    'status',
-                    'knownAmount',
-                    'reasonCodes',
-                    'forecastEligibleAmount',
-                    'oneTimeAmount',
-                    'unknownRecurrenceAmount',
-                    'forecastStatus',
-                ], ['forecastReasonCodes']) ||
-                !isCanonicalExactMoney({ amount: point.knownAmount, currencyCode: coordinate.accountingCurrency.currencyCode }) ||
+                !hasFinancialDataflowExactFieldsV1(point, ['date', 'compositionId', 'status', 'knownAmount', 'reasonCodes']) ||
+                !isCanonicalExactMoney({ amount: point.knownAmount, currencyCode: 'AUD' }) ||
                 !isReasonCodes(point.reasonCodes))
                 return false;
             partialDayCount += 1;
@@ -194,7 +143,9 @@ const isInputIdentity = (value) => {
         value.coverage.partialDayCount === partialDayCount &&
         value.coverage.unavailableDayCount === unavailableDayCount &&
         availableDayCount + partialDayCount + unavailableDayCount === expectedDays &&
-        cursor === requested.endDateExclusive);
+        cursor === requested.endDateExclusive &&
+        value.coordinate.period.gaps.length === gaps.length &&
+        value.coordinate.period.gaps.every(periodGap => gaps.some(gap => gap.startDate === periodGap.startDate && gap.endDateExclusive === periodGap.endDateExclusive)));
 };
 export const canonicalizeFinancialAnalyticsInputIdentityV1 = (value) => {
     if (!isFinancialDataflowValueWithinLimitsV1(value) || !isInputIdentity(value)) {
@@ -203,16 +154,9 @@ export const canonicalizeFinancialAnalyticsInputIdentityV1 = (value) => {
     return canonicalizeFinancialDataflowJsonV1({
         ...value,
         coordinate: { ...value.coordinate, providerAccountRefs: [...value.coordinate.providerAccountRefs].sort() },
-        referenceCompositions: [...value.referenceCompositions].sort((left, right) => left.compositionId.localeCompare(right.compositionId)),
         points: [...value.points]
             .sort((left, right) => left.date.localeCompare(right.date))
-            .map(point => ({
-            ...point,
-            ...(point.status === 'partial' ? { reasonCodes: [...point.reasonCodes].sort() } : {}),
-            ...(point.forecastReasonCodes === undefined
-                ? {}
-                : { forecastReasonCodes: [...point.forecastReasonCodes].sort() }),
-        })),
+            .map(point => (point.status === 'partial' ? { ...point, reasonCodes: [...point.reasonCodes].sort() } : point)),
         gaps: [...value.gaps]
             .sort((left, right) => `${left.startDate}\u0000${left.endDateExclusive}`.localeCompare(`${right.startDate}\u0000${right.endDateExclusive}`))
             .map(gap => ({ ...gap, reasonCodes: [...gap.reasonCodes].sort() })),
@@ -229,18 +173,6 @@ export const isFinancialAnalyticsInputSeriesV1 = (value) => {
 };
 const nextCalendarDate = (value) => new Date(Date.parse(`${value}T00:00:00.000Z`) + 86400000).toISOString().slice(0, 10);
 const hasSameReasonCodes = (left, right) => left.length === right.length && left.every(reasonCode => right.includes(reasonCode));
-const hasSameForecastSlice = (point, composition) => {
-    const selection = composition.chargeSelection;
-    return selection !== undefined &&
-        point.forecastEligibleAmount === selection.forecastEligibleAmount &&
-        point.oneTimeAmount === selection.oneTimeAmount &&
-        point.unknownRecurrenceAmount === selection.unknownRecurrenceAmount &&
-        point.forecastStatus === selection.forecastStatus &&
-        (point.forecastReasonCodes === undefined
-            ? selection.forecastReasonCodes === undefined
-            : selection.forecastReasonCodes !== undefined &&
-                hasSameReasonCodes(point.forecastReasonCodes, selection.forecastReasonCodes));
-};
 /** Proves that every analytics point is an exact projection of its referenced daily composition. */
 export const isFinancialAnalyticsInputSeriesCompatibleV1 = (input, dailyCompositions) => {
     if (!isFinancialAnalyticsInputSeriesV1(input) ||
@@ -256,7 +188,6 @@ export const isFinancialAnalyticsInputSeriesCompatibleV1 = (input, dailyComposit
     return input.points.every(point => {
         const composition = compositionById.get(point.compositionId);
         if (composition === undefined ||
-            composition.amount.status === 'unavailable' ||
             composition.coordinate.periodRole !== 'current-spend' ||
             composition.coordinate.period.windowKind !== 'daily' ||
             composition.coordinate.period.requested.startDate !== point.date ||
@@ -265,14 +196,11 @@ export const isFinancialAnalyticsInputSeriesCompatibleV1 = (input, dailyComposit
             return false;
         }
         if (point.status === 'available') {
-            return (composition.amount.status === 'available' &&
-                point.amount === composition.amount.amount &&
-                hasSameForecastSlice(point, composition));
+            return composition.amount.status === 'available' && point.amount === composition.amount.amount;
         }
         return (composition.amount.status === 'partial' &&
             point.knownAmount === composition.amount.knownAmount &&
-            hasSameReasonCodes(point.reasonCodes, composition.amount.reasonCodes) &&
-            hasSameForecastSlice(point, composition));
+            hasSameReasonCodes(point.reasonCodes, composition.amount.reasonCodes));
     });
 };
 const isResult = (value, currency) => {
@@ -306,6 +234,7 @@ const isResult = (value, currency) => {
     return (value.kind === 'anomaly' &&
         hasFinancialDataflowExactFieldsV1(value, ['kind', 'events']) &&
         Array.isArray(value.events) &&
+        value.events.length > 0 &&
         value.events.length <= MAX_POINTS &&
         value.events.every(event => {
             if (!isFinancialDataflowRecordV1(event) ||
@@ -354,9 +283,9 @@ const isProjectionIdentity = (value) => {
         return false;
     const currency = coordinateCurrency(value.coordinate);
     return (isFinancialDataflowHashV1(value.analyticsInputId) &&
-        isFinancialDataflowHashV1(value.currentSpendCompositionId) &&
         currency !== undefined &&
-        isResult(value.result, currency));
+        isResult(value.result, currency) &&
+        (value.result.kind === 'anomaly' || isFinancialDataflowHashV1(value.currentSpendCompositionId)));
 };
 export const canonicalizeFinancialAnalyticsProjectionIdentityV1 = (value) => {
     if (!isFinancialDataflowValueWithinLimitsV1(value) || !isProjectionIdentity(value)) {
@@ -405,24 +334,17 @@ export const isFinancialAnalyticsProjectionCompatibleV1 = (projection, input, cu
                 hasSameFinancialDimensions(projection.coordinate, currentSpendComposition.coordinate)));
     }
     if (projection.result.kind === 'anomaly') {
-        if (!isCurrentSpendCompositionV1(currentSpendComposition) ||
-            projection.currentSpendCompositionId !== currentSpendComposition.compositionId ||
-            !hasSameFinancialDimensions(projection.coordinate, currentSpendComposition.coordinate) ||
-            canonicalizeFinancialDataflowCoordinateV1({ ...projection.coordinate, periodRole: 'current-spend' }) !==
-                canonicalizeFinancialDataflowCoordinateV1(currentSpendComposition.coordinate) ||
-            !periodContains(input.coordinate, projection.coordinate)) {
+        if (projection.currentSpendCompositionId !== undefined &&
+            (!isCurrentSpendCompositionV1(currentSpendComposition) ||
+                projection.currentSpendCompositionId !== currentSpendComposition.compositionId ||
+                !hasSameFinancialDimensions(projection.coordinate, currentSpendComposition.coordinate))) {
             return false;
         }
         const pointsByDate = new Map(input.points.map(point => [point.date, point]));
         const eventDates = new Set();
-        const targetPeriod = projection.coordinate.period.requested;
         return projection.result.events.every(event => {
             const point = pointsByDate.get(event.date);
-            if (event.date < targetPeriod.startDate ||
-                event.date >= targetPeriod.endDateExclusive ||
-                point === undefined ||
-                eventDates.has(event.date) ||
-                (projection.status === 'available' && point.status !== 'available'))
+            if (point === undefined || eventDates.has(event.date) || (projection.status === 'available' && point.status !== 'available'))
                 return false;
             eventDates.add(event.date);
             const observedAmount = point.status === 'available' ? point.amount : point.knownAmount;
@@ -472,11 +394,7 @@ export const isFinancialAnalyticsProjectionCompatibleV1 = (projection, input, cu
             canonicalizeFinancialDataflowCoordinateV1(currentSpendComposition.coordinate)) {
         return false;
     }
-    if (projection.status === 'available' &&
-        currentSpendComposition.amount.status !== 'available' &&
-        !(currentSpendComposition.amount.status === 'partial' &&
-            currentSpendComposition.amount.reasonCodes.length === 1 &&
-            currentSpendComposition.amount.reasonCodes[0] === 'coverage-incomplete'))
+    if (projection.status === 'available' && currentSpendComposition.amount.status !== 'available')
         return false;
     if (currentSpendComposition.amount.status === 'unavailable')
         return false;

package/dist/esm/azure/financialAuthorityViewValidation.js

@@ -5,8 +5,6 @@ import { isFinancialEvidenceAssessmentV1 } from './financialEvidenceAssessmentVa
 import { formatExactDecimalValue, multiplyExactDecimalValues, parseCanonicalDecimal, sumCanonicalDecimals } from '../common/exactDecimal.js';
 import { isFinancialBaselinePeriodV2, isFinancialEvidenceBundleV1, isFinancialScopeBaselineEnvelopeV2 } from './financialScopeBaselineValidation.js';
 import { isFinancialAuthorityComponentDescriptorV1, isFinancialDisplayRollupV1 } from './financialDisplayRollupValidation.js';
-import { AZURE_BILLED_ALL_CHARGES_POLICY_V1 } from './financialChargeComposition.js';
-import { isFinancialChargeCompositionV1 } from './financialChargeCompositionValidation.js';
 const SHA256_ID = /^sha256:[0-9a-f]{64}$/;
 const CURRENCY = /^[A-Z]{3}$/;
 const AZURE_RESOURCE_TYPE = /^[a-z0-9.-]+\/[a-z0-9._/-]+$/;
@@ -57,7 +55,6 @@ const canonicalCoordinatePreimage = (value) => ({
     ownerBaselines: [...value.ownerBaselines].sort((left, right) => left.scopeId.localeCompare(right.scopeId)),
     residualBaseline: value.residualBaseline,
     aggregateBaseline: value.aggregateBaseline,
-    chargeCompositions: [...value.chargeCompositions].sort((left, right) => left.baselineId.localeCompare(right.baselineId)),
     componentDescriptors: [...value.componentDescriptors].sort((left, right) => `${left.baselineId}\u0000${left.componentId}`.localeCompare(`${right.baselineId}\u0000${right.componentId}`)),
     displayRollups: [...value.displayRollups].sort((left, right) => left.displayRollupId.localeCompare(right.displayRollupId)),
     projections: [...value.projections].sort((left, right) => left.scenarioId.localeCompare(right.scenarioId)),
@@ -98,7 +95,6 @@ const isCoordinate = (value, coveredScopeIds, financialRoleByScope, providerAcco
             'ownerBaselines',
             'residualBaseline',
             'aggregateBaseline',
-            'chargeCompositions',
             'componentDescriptors',
             'displayRollups',
             'projections',
@@ -117,9 +113,6 @@ const isCoordinate = (value, coveredScopeIds, financialRoleByScope, providerAcco
         !value.ownerBaselines.every(isFinancialScopeBaselineEnvelopeV2) ||
         !isFinancialScopeBaselineEnvelopeV2(value.residualBaseline) ||
         !isFinancialScopeBaselineEnvelopeV2(value.aggregateBaseline) ||
-        !Array.isArray(value.chargeCompositions) ||
-        value.chargeCompositions.length > 20001 ||
-        !value.chargeCompositions.every(isFinancialChargeCompositionV1) ||
         !Array.isArray(value.componentDescriptors) ||
         value.componentDescriptors.length > 20000 ||
         !value.componentDescriptors.every(isFinancialAuthorityComponentDescriptorV1) ||
@@ -180,38 +173,6 @@ const isCoordinate = (value, coveredScopeIds, financialRoleByScope, providerAcco
     }
     if (coordinate.residualBaseline.status === 'available' && !bundleIds.has(coordinate.residualBaseline.evidenceBundleId))
         return false;
-    const composableBaselines = [...coordinate.ownerBaselines, coordinate.residualBaseline].filter((baseline) => baseline.status === 'available' && baseline.baselineKind === 'owner');
-    const chargeCompositionByBaselineId = new Map(coordinate.chargeCompositions.map(composition => [composition.baselineId, composition]));
-    if (chargeCompositionByBaselineId.size !== coordinate.chargeCompositions.length ||
-        coordinate.chargeCompositions.length !== composableBaselines.length)
-        return false;
-    for (const baseline of composableBaselines) {
-        const composition = chargeCompositionByBaselineId.get(baseline.baselineId);
-        if (composition === undefined ||
-            canonicalText(baseline.chargeInclusionPolicyRef) !== canonicalText(AZURE_BILLED_ALL_CHARGES_POLICY_V1.policyRef) ||
-            composition.ownerScopeId !== baseline.scopeId ||
-            periodText(composition.period) !== periodText(baseline.period) ||
-            composition.costBasis !== baseline.costBasis ||
-            composition.estimateLens !== baseline.estimateLens ||
-            composition.accountingCurrencyCode !== baseline.total.currencyCode ||
-            composition.reconciliation.sourceTotal !== baseline.total.amount)
-            return false;
-        const baselineComponentById = new Map(baseline.components.map(component => [component.componentId, component]));
-        const partitionedComponentIds = composition.buckets.flatMap(bucket => bucket.componentIds);
-        if (partitionedComponentIds.length !== baseline.components.length ||
-            new Set(partitionedComponentIds).size !== partitionedComponentIds.length ||
-            partitionedComponentIds.some(componentId => !baselineComponentById.has(componentId)))
-            return false;
-        for (const bucket of composition.buckets) {
-            try {
-                if (formatExactDecimalValue(sumCanonicalDecimals(bucket.componentIds.map(componentId => baselineComponentById.get(componentId).amount))) !== bucket.amount)
-                    return false;
-            }
-            catch {
-                return false;
-            }
-        }
-    }
     const financialOwnerBaselines = coordinate.ownerBaselines.filter(baseline => financialRoleByScope.get(baseline.scopeId) === 'owner');
     const availableMembers = [...financialOwnerBaselines, coordinate.residualBaseline]
         .filter(baseline => baseline.status === 'available')
@@ -295,7 +256,7 @@ const isCoordinate = (value, coveredScopeIds, financialRoleByScope, providerAcco
             (projection.targetEvidenceBundleId !== undefined && !bundleIds.has(projection.targetEvidenceBundleId)) ||
             (targetAssessment !== undefined &&
                 (targetAssessment.request.scopeId !== projection.scopeId ||
-                    (projection.status === 'available' && targetAssessment.result !== 'available') ||
+                    targetAssessment.result !== 'available' ||
                     targetAssessment.evidenceBundleId !== projection.targetEvidenceBundleId)) ||
             (projection.baselineId !== undefined && (owner.status !== 'available' || projection.baselineId !== owner.baselineId)) ||
             (projection.status === 'available' && owner.status !== 'available'))
@@ -367,15 +328,6 @@ const isCoordinate = (value, coveredScopeIds, financialRoleByScope, providerAcco
                             return false;
                         continue;
                     }
-                    if (projection.operationKind === 'replace-quantity-and-rate') {
-                        if (!('targetQuantity' in applied) || !('targetRate' in applied))
-                            return false;
-                        if (applied.targetQuantity.unit !== applied.targetRate.quantityUnit ||
-                            applied.targetRate.currencyCode !== projection.accountingCurrencyCode ||
-                            formatExactDecimalValue(multiplyExactDecimalValues(parseCanonicalDecimal(applied.targetQuantity.amount), parseCanonicalDecimal(applied.targetRate.amount))) !== applied.targetAmount)
-                            return false;
-                        continue;
-                    }
                     if (!('sourceRate' in applied) || !('targetQuantity' in applied) || component.effectiveRate === undefined)
                         return false;
                     if (applied.sourceRate.amount !== component.effectiveRate.amount ||
@@ -543,225 +495,3 @@ export const isFinancialAuthorityViewV1 = (value) => {
 export const isFinancialAuthorityViewBoundToArtifactGenerationV1 = (value, expected) => isFinancialAuthorityViewV1(value) &&
     value.artifactGeneration.runId === expected.runId &&
     value.artifactGeneration.generatedAt === expected.generatedAt;
-const isSameProviderAccountSet = (left, right) => {
-    if (left.length !== right.length)
-        return false;
-    const sortedLeft = [...left].sort();
-    const sortedRight = [...right].sort();
-    return sortedLeft.every((value, index) => value === sortedRight[index]);
-};
-const isResourceProjectionCoordinate = (value, projection, assessmentById, bundleIds) => {
-    if (!isRecord(value) ||
-        !hasExactFields(value, [
-            'coordinateId',
-            'periodRole',
-            'period',
-            'costBasis',
-            'estimateLens',
-            'ownerBaseline',
-            'componentDescriptors',
-            'displayRollups',
-            'projections',
-        ], [
-            'requestedCurrencyCode',
-            'displayMemberBaselines',
-            'chargeComposition',
-            'displayMemberChargeCompositions',
-        ]) ||
-        !isHash(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 && (typeof value.requestedCurrencyCode !== 'string' || !CURRENCY.test(value.requestedCurrencyCode))) ||
-        !isFinancialScopeBaselineEnvelopeV2(value.ownerBaseline) ||
-        (value.displayMemberBaselines !== undefined &&
-            (!Array.isArray(value.displayMemberBaselines) ||
-                value.displayMemberBaselines.length > 20000 ||
-                !value.displayMemberBaselines.every(isFinancialScopeBaselineEnvelopeV2))) ||
-        (value.chargeComposition !== undefined && !isFinancialChargeCompositionV1(value.chargeComposition)) ||
-        (value.displayMemberChargeCompositions !== undefined &&
-            (!Array.isArray(value.displayMemberChargeCompositions) ||
-                value.displayMemberChargeCompositions.length > 20000 ||
-                !value.displayMemberChargeCompositions.every(isFinancialChargeCompositionV1))) ||
-        !Array.isArray(value.componentDescriptors) ||
-        value.componentDescriptors.length > 20000 ||
-        !value.componentDescriptors.every(isFinancialAuthorityComponentDescriptorV1) ||
-        !Array.isArray(value.displayRollups) ||
-        value.displayRollups.length > 20000 ||
-        !value.displayRollups.every(isFinancialDisplayRollupV1) ||
-        !Array.isArray(value.projections) ||
-        value.projections.length > 20000 ||
-        !value.projections.every(isFinancialProjectionEnvelopeV1))
-        return false;
-    const coordinate = value;
-    const baseline = coordinate.ownerBaseline;
-    const displayMemberBaselines = coordinate.displayMemberBaselines ?? [];
-    const displayMemberChargeCompositions = coordinate.displayMemberChargeCompositions ?? [];
-    const assessment = assessmentById.get(baseline.assessmentId);
-    if (normalizeScopeId(baseline.scopeId) !== projection.scopeId ||
-        baseline.costBasis !== coordinate.costBasis ||
-        baseline.estimateLens !== coordinate.estimateLens ||
-        periodText(baseline.period) !== periodText(coordinate.period) ||
-        baseline.requestedCurrencyCode !== coordinate.requestedCurrencyCode ||
-        !isSameProviderAccountSet(baseline.providerAccountRefs, projection.providerAccountRefs) ||
-        !assessment ||
-        assessment.request.scopeId !== baseline.scopeId ||
-        assessment.request.scopeKind !== baseline.scopeKind ||
-        assessment.result !== baseline.status)
-        return false;
-    if (projection.financialRole === 'display-only' && (baseline.status !== 'unavailable' || baseline.unavailableReason !== 'unsupported-scope')) {
-        return false;
-    }
-    if (projection.financialRole === 'unclassified' && (baseline.status !== 'unavailable' || baseline.unavailableReason !== 'ownership-unresolved')) {
-        return false;
-    }
-    if (baseline.status !== 'available' || baseline.baselineKind !== 'owner') {
-        return (displayMemberBaselines.length === 0 &&
-            coordinate.chargeComposition === undefined &&
-            displayMemberChargeCompositions.length === 0 &&
-            coordinate.componentDescriptors.length === 0 &&
-            coordinate.displayRollups.length === 0 &&
-            coordinate.projections.every(projectionValue => normalizeScopeId(projectionValue.scopeId) === projection.scopeId) &&
-            new Set(coordinate.projections.map(projectionValue => projectionValue.scenarioId)).size === coordinate.projections.length);
-    }
-    if (baseline.scopeKind !== 'canonical-resource-owner' && baseline.scopeKind !== 'composite-resource')
-        return false;
-    if (!bundleIds.has(baseline.evidenceBundleId) || assessment.evidenceBundleId !== baseline.evidenceBundleId)
-        return false;
-    const availableDisplayMemberBaselines = displayMemberBaselines.filter((candidate) => candidate.status === 'available' && candidate.baselineKind === 'owner');
-    if (availableDisplayMemberBaselines.length !== displayMemberBaselines.length)
-        return false;
-    const projectedBaselines = [baseline, ...availableDisplayMemberBaselines];
-    if (new Set(projectedBaselines.map(candidate => candidate.baselineId)).size !== projectedBaselines.length ||
-        displayMemberBaselines.some(candidate => {
-            if (candidate.status !== 'available' ||
-                candidate.baselineKind !== 'owner' ||
-                (candidate.scopeKind !== 'canonical-resource-owner' && candidate.scopeKind !== 'composite-resource') ||
-                candidate.costBasis !== coordinate.costBasis ||
-                candidate.estimateLens !== coordinate.estimateLens ||
-                periodText(candidate.period) !== periodText(coordinate.period) ||
-                candidate.requestedCurrencyCode !== coordinate.requestedCurrencyCode ||
-                candidate.total.currencyCode !== baseline.total.currencyCode ||
-                !isSameProviderAccountSet(candidate.providerAccountRefs, projection.providerAccountRefs) ||
-                !bundleIds.has(candidate.evidenceBundleId))
-                return true;
-            const candidateAssessment = assessmentById.get(candidate.assessmentId);
-            return (!candidateAssessment ||
-                candidateAssessment.request.scopeId !== candidate.scopeId ||
-                candidateAssessment.request.scopeKind !== candidate.scopeKind ||
-                candidateAssessment.result !== candidate.status ||
-                candidateAssessment.evidenceBundleId !== candidate.evidenceBundleId);
-        }))
-        return false;
-    const compositions = [coordinate.chargeComposition, ...displayMemberChargeCompositions];
-    if (compositions.some(candidate => candidate === undefined))
-        return false;
-    const compositionByBaselineId = new Map(compositions.map(candidate => [candidate.baselineId, candidate]));
-    if (compositions.length !== projectedBaselines.length || compositionByBaselineId.size !== projectedBaselines.length)
-        return false;
-    for (const projectedBaseline of projectedBaselines) {
-        const composition = compositionByBaselineId.get(projectedBaseline.baselineId);
-        if (!composition ||
-            composition.baselineId !== projectedBaseline.baselineId ||
-            normalizeScopeId(composition.ownerScopeId) !== normalizeScopeId(projectedBaseline.scopeId) ||
-            periodText(composition.period) !== periodText(projectedBaseline.period) ||
-            composition.costBasis !== projectedBaseline.costBasis ||
-            composition.estimateLens !== projectedBaseline.estimateLens ||
-            composition.accountingCurrencyCode !== projectedBaseline.total.currencyCode ||
-            composition.reconciliation.sourceTotal !== projectedBaseline.total.amount)
-            return false;
-    }
-    const composition = coordinate.chargeComposition;
-    if (!composition ||
-        composition.baselineId !== baseline.baselineId ||
-        normalizeScopeId(composition.ownerScopeId) !== projection.scopeId ||
-        periodText(composition.period) !== periodText(baseline.period) ||
-        composition.costBasis !== baseline.costBasis ||
-        composition.estimateLens !== baseline.estimateLens ||
-        composition.accountingCurrencyCode !== baseline.total.currencyCode ||
-        composition.reconciliation.sourceTotal !== baseline.total.amount)
-        return false;
-    const componentKeys = new Set(projectedBaselines.flatMap(projectedBaseline => projectedBaseline.components.map(component => `${projectedBaseline.baselineId}\u0000${component.componentId}`)));
-    const ownerComponentKeys = new Set(baseline.components.map(component => `${baseline.baselineId}\u0000${component.componentId}`));
-    const descriptorKeys = coordinate.componentDescriptors.map(descriptor => `${descriptor.baselineId}\u0000${descriptor.componentId}`);
-    if (descriptorKeys.length !== componentKeys.size ||
-        new Set(descriptorKeys).size !== descriptorKeys.length ||
-        descriptorKeys.some(key => !componentKeys.has(key)) ||
-        coordinate.displayRollups.some(rollup => normalizeScopeId(rollup.displayScopeId) !== projection.scopeId ||
-            rollup.members.some(member => !componentKeys.has(`${member.baselineId}\u0000${member.componentId}`))) ||
-        coordinate.projections.some(projectionValue => normalizeScopeId(projectionValue.scopeId) !== projection.scopeId))
-        return false;
-    const rolledUpKeys = coordinate.displayRollups.flatMap(rollup => rollup.members.map(member => `${member.baselineId}\u0000${member.componentId}`));
-    return (ownerComponentKeys.size > 0 &&
-        new Set(rolledUpKeys).size === rolledUpKeys.length &&
-        rolledUpKeys.every(key => componentKeys.has(key)) &&
-        [...ownerComponentKeys].every(key => rolledUpKeys.includes(key)) &&
-        [...componentKeys].every(key => rolledUpKeys.includes(key)) &&
-        new Set(coordinate.projections.map(projectionValue => projectionValue.scenarioId)).size === coordinate.projections.length);
-};
-/** Strictly validates one bounded, non-additive resource projection without requiring the full authority ledger. */
-export const isFinancialAuthorityResourceProjectionV1 = (value) => {
-    if (!isRecord(value) ||
-        !hasExactFields(value, [
-            'contractVersion',
-            'authorityId',
-            'provider',
-            'providerAccountRefs',
-            'artifactGeneration',
-            'billingGenerationId',
-            'resourceType',
-            'financialRole',
-            'scopeId',
-            'evidenceBundles',
-            'evidenceAssessments',
-            'coordinates',
-        ]) ||
-        value.contractVersion !== 'financial-authority-resource-projection/v1' ||
-        !isHash(value.authorityId) ||
-        value.provider !== 'azure' ||
-        !Array.isArray(value.providerAccountRefs) ||
-        value.providerAccountRefs.length === 0 ||
-        value.providerAccountRefs.length > 64 ||
-        !value.providerAccountRefs.every(isIdentity) ||
-        new Set(value.providerAccountRefs).size !== value.providerAccountRefs.length ||
-        !isRecord(value.artifactGeneration) ||
-        !hasExactFields(value.artifactGeneration, ['runId', 'generatedAt']) ||
-        !isIdentity(value.artifactGeneration.runId) ||
-        !isIsoInstant(value.artifactGeneration.generatedAt) ||
-        !isIdentity(value.billingGenerationId) ||
-        typeof value.resourceType !== 'string' ||
-        !AZURE_RESOURCE_TYPE.test(value.resourceType) ||
-        value.resourceType !== normalizeScopeId(value.resourceType) ||
-        (value.financialRole !== 'owner' && value.financialRole !== 'display-only' && value.financialRole !== 'unclassified') ||
-        !isIdentity(value.scopeId) ||
-        value.scopeId !== normalizeScopeId(value.scopeId) ||
-        !Array.isArray(value.evidenceBundles) ||
-        value.evidenceBundles.length > 20000 ||
-        !value.evidenceBundles.every(isFinancialEvidenceBundleV1) ||
-        !Array.isArray(value.evidenceAssessments) ||
-        value.evidenceAssessments.length > 20000 ||
-        !value.evidenceAssessments.every(isFinancialEvidenceAssessmentV1) ||
-        !Array.isArray(value.coordinates) ||
-        value.coordinates.length === 0 ||
-        value.coordinates.length > 128)
-        return false;
-    const projection = value;
-    const bundleIds = new Set(projection.evidenceBundles.map(bundle => bundle.bundleId));
-    const assessmentById = new Map(projection.evidenceAssessments.map(assessment => [assessment.assessmentId, assessment]));
-    const projectedScopeIds = new Set([
-        projection.scopeId,
-        ...projection.coordinates.flatMap(coordinate => (coordinate.displayMemberBaselines ?? []).map(baseline => normalizeScopeId(baseline.scopeId))),
-    ]);
-    if (bundleIds.size !== projection.evidenceBundles.length || assessmentById.size !== projection.evidenceAssessments.length)
-        return false;
-    if (projection.evidenceAssessments.some(assessment => (assessment.evidenceBundleId !== undefined && !bundleIds.has(assessment.evidenceBundleId)) ||
-        !isSameProviderAccountSet(assessment.request.providerAccountRefs, projection.providerAccountRefs) ||
-        !projectedScopeIds.has(normalizeScopeId(assessment.request.scopeId))) ||
-        !projection.coordinates.every(coordinate => isResourceProjectionCoordinate(coordinate, projection, assessmentById, bundleIds)) ||
-        new Set(projection.coordinates.map(coordinate => coordinate.coordinateId)).size !== projection.coordinates.length)
-        return false;
-    return true;
-};