@spottoai/types-package 1.0.2-beta.99 → 1.0.2-dev1138.12

package/dist/esm/azure/financialSavingsSurfaceProjectionValidation.js

@@ -0,0 +1,357 @@
+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 { isFinancialChargeInclusionPolicyRefV1 } from './financialChargeCompositionValidation.js';
+import { isCanonicalExactMoney } from './financialValidationPrimitives.js';
+import { composeFinancialSavingsAllocationPercentageV1 } from './financialSavingsPercentageKernel.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(),
+    ...(value.lifecycleBindings === undefined
+        ? {}
+        : {
+            lifecycleBindings: [...value.lifecycleBindings]
+                .sort((left, right) => left.resourceId.localeCompare(right.resourceId) || left.recommendationId.localeCompare(right.recommendationId))
+                .map(binding => ({ ...binding, allocationIds: [...binding.allocationIds].sort() })),
+        }),
+    scope: value.scope.kind === 'subscription-full'
+        ? value.scope
+        : value.scope.kind === 'recommendation-query'
+            ? { ...value.scope, recommendationIds: [...value.scope.recommendationIds].sort() }
+            : {
+                ...value.scope,
+                allocationIds: [...value.scope.allocationIds].sort(),
+                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(),
+                ...(contribution.allocations === undefined
+                    ? {}
+                    : {
+                        allocations: [...contribution.allocations].sort((left, right) => left.allocationId.localeCompare(right.allocationId)),
+                    }),
+            })),
+            ...(coordinate.resourceContributions === undefined
+                ? {}
+                : {
+                    resourceContributions: [...coordinate.resourceContributions]
+                        .sort((left, right) => left.resourceId.localeCompare(right.resourceId))
+                        .map(contribution => ({
+                        ...contribution,
+                        allocationIds: [...contribution.allocationIds].sort(),
+                        denominator: {
+                            ...contribution.denominator,
+                            denominatorIds: [...contribution.denominator.denominatorIds].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']);
+    if (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)
+        return true;
+    return (value.kind === 'resource-query' &&
+        hasExactFinancialSavingsFields(value, ['kind', 'filterFingerprint', 'allocationIds', 'recommendationIds']) &&
+        isFinancialSavingsHash(value.filterFingerprint) &&
+        Array.isArray(value.allocationIds) &&
+        value.allocationIds.length <= MAX_ALLOCATIONS &&
+        value.allocationIds.every(isFinancialSavingsHash) &&
+        new Set(value.allocationIds).size === value.allocationIds.length &&
+        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) &&
+    isFinancialChargeInclusionPolicyRefV1(value.chargeInclusionPolicyRef) &&
+    (value.requestedCurrencyCode === undefined || isCurrency(value.requestedCurrencyCode)) &&
+    (value.currentAggregateBaselineId === undefined || isFinancialSavingsHash(value.currentAggregateBaselineId));
+const isLifecycleBinding = (value) => isFinancialSavingsRecord(value) &&
+    hasExactFinancialSavingsFields(value, ['resourceId', 'recommendationId', 'allocationIds']) &&
+    isFinancialSavingsIdentity(value.resourceId) &&
+    isFinancialSavingsIdentity(value.recommendationId) &&
+    Array.isArray(value.allocationIds) &&
+    value.allocationIds.length > 0 &&
+    value.allocationIds.length <= MAX_ALLOCATIONS &&
+    value.allocationIds.every(isFinancialSavingsHash) &&
+    new Set(value.allocationIds).size === value.allocationIds.length;
+const isComposedCoordinate = (value, queryRecommendationIds, queryAllocationIds) => {
+    const partial = value.status === 'partial';
+    if (!hasExactFinancialSavingsFields(value, [
+        'status',
+        'coordinateId',
+        'periodRole',
+        'period',
+        'costBasis',
+        'estimateLens',
+        'chargeInclusionPolicyRef',
+        'currentAggregateBaselineId',
+        'currentAggregate',
+        'accountingCurrencyCode',
+        'minorUnitScale',
+        'roundingMode',
+        'recommendationContributions',
+        'aggregate',
+        ...(partial ? ['unavailableRecommendationIds'] : []),
+    ], ['requestedCurrencyCode', 'resourceContributions']) ||
+        !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;
+    if (partial &&
+        (!Array.isArray(value.unavailableRecommendationIds) ||
+            value.unavailableRecommendationIds.length === 0 ||
+            value.unavailableRecommendationIds.length > MAX_ALLOCATIONS ||
+            !value.unavailableRecommendationIds.every(isFinancialSavingsIdentity) ||
+            new Set(value.unavailableRecommendationIds).size !== value.unavailableRecommendationIds.length ||
+            (queryRecommendationIds !== undefined && value.unavailableRecommendationIds.some(id => !queryRecommendationIds.has(id)))))
+        return false;
+    const recommendationIds = new Set();
+    const allocationIds = [];
+    const contributionAmounts = [];
+    const allocationById = new Map();
+    for (const contribution of value.recommendationContributions) {
+        if (!isFinancialSavingsRecord(contribution) ||
+            !hasExactFinancialSavingsFields(contribution, ['recommendationId', 'allocationIds', 'savingsMinorUnits'], ['allocations']) ||
+            !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) ||
+            (queryAllocationIds !== undefined && !Array.isArray(contribution.allocations)) ||
+            (contribution.allocations !== undefined &&
+                (!Array.isArray(contribution.allocations) || contribution.allocations.length !== contribution.allocationIds.length)))
+            return false;
+        const exactAllocations = contribution.allocations;
+        if (exactAllocations === undefined) {
+            recommendationIds.add(contribution.recommendationId);
+            allocationIds.push(...contribution.allocationIds);
+            contributionAmounts.push(contribution.savingsMinorUnits);
+            continue;
+        }
+        const exactAllocationIds = [];
+        const exactAllocationAmounts = [];
+        for (const allocation of exactAllocations) {
+            if (!isFinancialSavingsRecord(allocation) ||
+                !hasExactFinancialSavingsFields(allocation, ['allocationId', 'savingsMinorUnits'], ['denominator']) ||
+                !isFinancialSavingsHash(allocation.allocationId) ||
+                (queryAllocationIds !== undefined && !queryAllocationIds.has(allocation.allocationId)) ||
+                !isFinancialSavingsMinorUnits(allocation.savingsMinorUnits) ||
+                (allocation.denominator !== undefined &&
+                    (!isFinancialSavingsRecord(allocation.denominator) ||
+                        !hasExactFinancialSavingsFields(allocation.denominator, ['denominatorId', 'amount', 'currencyCode']) ||
+                        !isFinancialSavingsHash(allocation.denominator.denominatorId) ||
+                        !isCanonicalExactMoney({
+                            amount: allocation.denominator.amount,
+                            currencyCode: allocation.denominator.currencyCode,
+                        }))))
+                return false;
+            exactAllocationIds.push(allocation.allocationId);
+            exactAllocationAmounts.push(allocation.savingsMinorUnits);
+            allocationById.set(allocation.allocationId, allocation);
+        }
+        if (new Set(exactAllocationIds).size !== exactAllocationIds.length ||
+            !haveSameFinancialSavingsSet(exactAllocationIds, contribution.allocationIds) ||
+            sumFinancialSavingsMinorUnits(exactAllocationAmounts) !== contribution.savingsMinorUnits)
+            return false;
+        recommendationIds.add(contribution.recommendationId);
+        allocationIds.push(...contribution.allocationIds);
+        contributionAmounts.push(contribution.savingsMinorUnits);
+    }
+    if (value.resourceContributions !== undefined) {
+        if (!Array.isArray(value.resourceContributions) || value.resourceContributions.length > MAX_ALLOCATIONS)
+            return false;
+        const resourceIds = new Set();
+        const resourceAllocationIds = [];
+        for (const contribution of value.resourceContributions) {
+            if (!isFinancialSavingsRecord(contribution) ||
+                !hasExactFinancialSavingsFields(contribution, ['resourceId', 'allocationIds', 'savingsMinorUnits', 'denominator', 'percentage']) ||
+                !isFinancialSavingsIdentity(contribution.resourceId) ||
+                resourceIds.has(contribution.resourceId) ||
+                !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) ||
+                !isFinancialSavingsRecord(contribution.denominator) ||
+                !hasExactFinancialSavingsFields(contribution.denominator, ['denominatorIds', 'amount', 'currencyCode']) ||
+                !Array.isArray(contribution.denominator.denominatorIds) ||
+                contribution.denominator.denominatorIds.length === 0 ||
+                !contribution.denominator.denominatorIds.every(isFinancialSavingsHash) ||
+                new Set(contribution.denominator.denominatorIds).size !== contribution.denominator.denominatorIds.length ||
+                !isCanonicalExactMoney({ amount: contribution.denominator.amount, currencyCode: contribution.denominator.currencyCode }) ||
+                typeof contribution.percentage !== 'number' ||
+                !Number.isFinite(contribution.percentage) ||
+                contribution.percentage < 0)
+                return false;
+            const allocations = contribution.allocationIds.map(allocationId => allocationById.get(allocationId));
+            if (allocations.some(allocation => allocation === undefined))
+                return false;
+            const exactAllocations = allocations;
+            const composed = composeFinancialSavingsAllocationPercentageV1(exactAllocations, Number(value.minorUnitScale));
+            if (!composed ||
+                sumFinancialSavingsMinorUnits(exactAllocations.map(allocation => allocation.savingsMinorUnits)) !==
+                    contribution.savingsMinorUnits ||
+                !haveSameFinancialSavingsSet(composed.denominatorIds, contribution.denominator.denominatorIds) ||
+                composed.denominatorAmount !== contribution.denominator.amount ||
+                composed.denominatorCurrencyCode !== contribution.denominator.currencyCode ||
+                composed.percentage !== contribution.percentage)
+                return false;
+            resourceIds.add(contribution.resourceId);
+            resourceAllocationIds.push(...contribution.allocationIds);
+        }
+        if (new Set(resourceAllocationIds).size !== resourceAllocationIds.length ||
+            !haveSameFinancialSavingsSet(resourceAllocationIds, allocationIds))
+            return false;
+    }
+    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', 'chargeInclusionPolicyRef', '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',
+        ], ['lifecycleBindings']) ||
+        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 !== 'resources' && value.surface !== 'dashboard') ||
+        !isScope(value.scope) ||
+        (value.surface === 'dashboard' && value.scope.kind !== 'subscription-full') ||
+        (value.surface === 'recommendations' && value.scope.kind === 'resource-query') ||
+        (value.surface === 'resources' && value.scope.kind === 'recommendation-query') ||
+        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) ||
+        (value.lifecycleBindings !== undefined &&
+            (!Array.isArray(value.lifecycleBindings) ||
+                value.lifecycleBindings.length === 0 ||
+                value.lifecycleBindings.length > MAX_ALLOCATIONS ||
+                !value.lifecycleBindings.every(isLifecycleBinding))) ||
+        !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' || projection.scope.kind === 'resource-query'
+        ? new Set(projection.scope.recommendationIds)
+        : undefined;
+    const queryAllocationIds = projection.scope.kind === 'resource-query' ? new Set(projection.scope.allocationIds) : undefined;
+    if (!projection.coordinates.every(coordinate => {
+        if (!isFinancialSavingsRecord(coordinate))
+            return false;
+        return coordinate.status === 'available' || coordinate.status === 'partial'
+            ? isComposedCoordinate(coordinate, queryRecommendationIds, queryAllocationIds)
+            : coordinate.status === 'unavailable' && isUnavailableCoordinate(coordinate);
+    }) ||
+        new Set(projection.coordinates.map(coordinate => coordinate.coordinateId)).size !== projection.coordinates.length)
+        return false;
+    if (projection.lifecycleBindings !== undefined) {
+        const lifecycleKeys = projection.lifecycleBindings.map(binding => `${binding.resourceId}\u0000${binding.recommendationId}`);
+        const boundAllocationIds = projection.lifecycleBindings.flatMap(binding => binding.allocationIds);
+        const projectedAllocationOwners = new Map();
+        for (const coordinate of projection.coordinates) {
+            if (coordinate.status === 'unavailable')
+                continue;
+            for (const contribution of coordinate.recommendationContributions) {
+                for (const allocationId of contribution.allocationIds) {
+                    if (projectedAllocationOwners.has(allocationId))
+                        return false;
+                    projectedAllocationOwners.set(allocationId, contribution.recommendationId);
+                }
+            }
+        }
+        if (new Set(lifecycleKeys).size !== lifecycleKeys.length ||
+            new Set(boundAllocationIds).size !== boundAllocationIds.length ||
+            boundAllocationIds.length !== projectedAllocationOwners.size ||
+            projection.lifecycleBindings.some(binding => binding.allocationIds.some(allocationId => projectedAllocationOwners.get(allocationId) !== binding.recommendationId)))
+            return false;
+    }
+    const { projectionId: _projectionId, ...identity } = projection;
+    return projection.projectionId === createFinancialSavingsSurfaceProjectionIdV1(identity);
+};

package/dist/esm/azure/financialScope.js

@@ -0,0 +1,39 @@
+export * from './financialScopeEvidence.js';
+export * from './financialEvidenceCoverage.js';
+export * from './financialScopeBaseline.js';
+export * from './financialScopeBaselineIdentity.js';
+export * from './financialScopeBaselineValidation.js';
+export * from './financialChargeComposition.js';
+export * from './financialChargeCompositionValidation.js';
+export * from './financialChargeCompositionKernel.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 './financialAuthorityProjectionKernel.js';
+export * from './financialSavingsAuthority.js';
+export * from './financialSavingsAuthorityValidation.js';
+export * from './financialSavingsSurfaceProjection.js';
+export * from './financialSavingsSurfaceProjectionValidation.js';
+export * from './financialSavingsSurfaceProjectionKernel.js';
+export * from './financialSavingsPercentageKernel.js';
+export * from './financialCurrentSpendSurfaceProjection.js';
+export * from './financialCurrentSpendSurfaceProjectionValidation.js';
+export * from './financialResourceSurfaceProjection.js';
+export * from './financialResourceSurfaceProjectionValidation.js';
+export * from './financialDataflow.js';
+export * from './financialDataflowValidation.js';
+export * from './financialDataflowKernel.js';
+export * from './financialAnalytics.js';
+export * from './financialAnalyticsValidation.js';
+export * from './financialAnalyticsDisplayKernel.js';
+export * from './financialAnalyticsDelivery.js';
+export * from './financialAnalyticsDeliveryValidation.js';
+export * from './financialPolicy.js';
+export * from './financialPolicyValidation.js';
+export * from './financialPolicyKernel.js';
+export * from './financialPolicyDelivery.js';
+export * from './financialPolicyDeliveryValidation.js';

package/dist/esm/azure/financialScopeBaseline.js

@@ -0,0 +1,31 @@
+export const FINANCIAL_SCOPE_BASELINE_SCHEMA_VERSION_V2 = 2;
+export const FINANCIAL_SCOPE_BASELINE_CONTRACT_VERSION_V2 = 'financial-scope-baseline/v2';
+/**
+ * True only when the produced evidence covers the entire requested interval.
+ * Partial periods remain valid monetary evidence for display and forecasting,
+ * but must not be used as the current side of an optimization projection.
+ */
+export const isCompleteFinancialBaselinePeriodV2 = (period) => period.observed !== undefined &&
+    period.observed.startDate === period.requested.startDate &&
+    period.observed.endDateExclusive === period.requested.endDateExclusive &&
+    period.observed.dateBasis === period.requested.dateBasis &&
+    period.observed.timeZone === period.requested.timeZone &&
+    period.gaps.length === 0;
+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',
+    'scope-membership-empty',
+    'unsupported-scope',
+];

package/dist/esm/azure/financialScopeBaselineIdentity.js

@@ -0,0 +1,149 @@
+const compareCodePoints = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
+const canonicalInterval = (interval) => ({
+    startDate: interval.startDate,
+    endDateExclusive: interval.endDateExclusive,
+    dateBasis: interval.dateBasis,
+    ...(interval.timeZone === undefined ? {} : { timeZone: interval.timeZone }),
+});
+const canonicalEvidenceReference = (reference) => ({
+    evidenceRefId: reference.evidenceRefId,
+    role: reference.role,
+    sourceKind: reference.sourceKind,
+    ...(reference.generationId === undefined ? {} : { generationId: reference.generationId }),
+    ...(reference.revisionId === undefined ? {} : { revisionId: reference.revisionId }),
+    digestAlgorithm: reference.digestAlgorithm,
+    evidenceDigest: reference.evidenceDigest,
+    intrinsicTime: {
+        kind: reference.intrinsicTime.kind,
+        at: reference.intrinsicTime.at,
+    },
+    ...(reference.effectivePeriod === undefined ? {} : { effectivePeriod: canonicalInterval(reference.effectivePeriod) }),
+});
+/** Canonical UTF-8 text for a validated immutable evidence-bundle identity. */
+export const canonicalizeValidatedFinancialEvidenceBundleIdentityV1 = (value) => JSON.stringify({
+    schemaVersion: value.schemaVersion,
+    contractVersion: value.contractVersion,
+    references: [...value.references]
+        .sort((left, right) => compareCodePoints(left.evidenceRefId, right.evidenceRefId))
+        .map(canonicalEvidenceReference),
+});
+/** Canonical UTF-8 text for a validated evidence-assessment identity. */
+export const canonicalizeValidatedFinancialEvidenceAssessmentIdentityV1 = (value) => JSON.stringify({
+    schemaVersion: value.schemaVersion,
+    contractVersion: value.contractVersion,
+    policyVersion: value.policyVersion,
+    evaluatedAt: value.evaluatedAt,
+    request: {
+        provider: value.request.provider,
+        providerAccountRefs: [...value.request.providerAccountRefs].sort(compareCodePoints),
+        scopeKind: value.request.scopeKind,
+        scopeId: value.request.scopeId,
+        requestedEvidenceRoles: [...value.request.requestedEvidenceRoles].sort(compareCodePoints),
+    },
+    roleAssessments: [...value.roleAssessments]
+        .sort((left, right) => compareCodePoints(left.role, right.role))
+        .map(item => ({
+        role: item.role,
+        support: item.support,
+        requestState: item.requestState,
+        productionState: item.productionState,
+        matchState: item.matchState,
+        ...(item.evidenceRefId === undefined ? {} : { evidenceRefId: item.evidenceRefId }),
+    })),
+    completeness: value.completeness,
+    reconciliation: value.reconciliation,
+    freshness: value.freshness,
+    result: value.result,
+    primaryReason: value.primaryReason,
+    supportingReasons: [...value.supportingReasons].sort(compareCodePoints),
+    ...(value.evidenceBundleId === undefined ? {} : { evidenceBundleId: value.evidenceBundleId }),
+    summary: {
+        requestedRoleCount: value.summary.requestedRoleCount,
+        producedRoleCount: value.summary.producedRoleCount,
+        matchedRoleCount: value.summary.matchedRoleCount,
+    },
+});
+const canonicalCoverage = (coverage) => ({
+    coverageId: coverage.coverageId,
+    interval: canonicalInterval(coverage.interval),
+    settlementState: coverage.settlementState,
+    evidenceRefIds: [...coverage.evidenceRefIds].sort(compareCodePoints),
+});
+const canonicalPeriod = (period) => ({
+    windowKind: period.windowKind,
+    requested: canonicalInterval(period.requested),
+    ...(period.observed === undefined ? {} : { observed: canonicalInterval(period.observed) }),
+    ...(period.providerBillingPeriodId === undefined ? {} : { providerBillingPeriodId: period.providerBillingPeriodId }),
+    coverage: [...period.coverage].sort((left, right) => compareCodePoints(left.coverageId, right.coverageId)).map(canonicalCoverage),
+    gaps: [...period.gaps]
+        .sort((left, right) => compareCodePoints(`${left.startDate}:${left.endDateExclusive}`, `${right.startDate}:${right.endDateExclusive}`))
+        .map(canonicalInterval),
+});
+const canonicalComponent = (component) => ({
+    componentId: component.componentId,
+    billableIdentity: component.billableIdentity,
+    ownerScopeId: component.ownerScopeId,
+    chargeClassification: component.chargeClassification,
+    amount: component.amount,
+    ...(component.estimateReason === undefined ? {} : { estimateReason: component.estimateReason }),
+    evidenceRefIds: [...component.evidenceRefIds].sort(compareCodePoints),
+    coverageIds: [...component.coverageIds].sort(compareCodePoints),
+    ...(component.quantity === undefined
+        ? {}
+        : { quantity: { amount: component.quantity.amount, unit: component.quantity.unit } }),
+    ...(component.effectiveRate === undefined
+        ? {}
+        : {
+            effectiveRate: {
+                amount: component.effectiveRate.amount,
+                unit: component.effectiveRate.unit,
+                currencyCode: component.effectiveRate.currencyCode,
+            },
+        }),
+});
+/** Canonical UTF-8 text for a validated owner or aggregate baseline identity. */
+export const canonicalizeValidatedFinancialScopeBaselineIdentityV2 = (value) => {
+    const common = {
+        schemaVersion: value.schemaVersion,
+        contractVersion: value.contractVersion,
+        provider: value.provider,
+        providerAccountRefs: [...value.providerAccountRefs].sort(compareCodePoints),
+        scopeKind: value.scopeKind,
+        scopeId: value.scopeId,
+        period: canonicalPeriod(value.period),
+        costBasis: value.costBasis,
+        estimateLens: value.estimateLens,
+        ...(value.requestedCurrencyCode === undefined ? {} : { requestedCurrencyCode: value.requestedCurrencyCode }),
+        assessmentId: value.assessmentId,
+        baselineKind: value.baselineKind,
+    };
+    if (value.baselineKind === 'owner') {
+        return JSON.stringify({
+            ...common,
+            evidenceBundleId: value.evidenceBundleId,
+            accountingCurrency: {
+                currencyCode: value.accountingCurrency.currencyCode,
+                sourceCurrencyCode: value.accountingCurrency.sourceCurrencyCode,
+                evidenceRefIds: [...value.accountingCurrency.evidenceRefIds].sort(compareCodePoints),
+                ...(value.accountingCurrency.fxEvidenceRefId === undefined ? {} : { fxEvidenceRefId: value.accountingCurrency.fxEvidenceRefId }),
+            },
+            chargeInclusionPolicyRef: {
+                policyId: value.chargeInclusionPolicyRef.policyId,
+                policyDigest: value.chargeInclusionPolicyRef.policyDigest,
+            },
+            components: [...value.components].sort((left, right) => compareCodePoints(left.componentId, right.componentId)).map(canonicalComponent),
+        });
+    }
+    return JSON.stringify({
+        ...common,
+        accountingCurrencyCode: value.accountingCurrencyCode,
+        memberBaselineIds: [...value.memberBaselineIds].sort(compareCodePoints),
+        compatibility: {
+            period: value.compatibility.period,
+            costBasis: value.compatibility.costBasis,
+            estimateLens: value.compatibility.estimateLens,
+            accountingCurrency: value.compatibility.accountingCurrency,
+            membership: value.compatibility.membership,
+        },
+    });
+};