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

package/dist/esm/azure/financialPolicyValidation.js

@@ -0,0 +1,553 @@
+import { multiplyExactDecimalValues, parseCanonicalDecimal, subtractExactDecimalValues } from '../common/exactDecimal.js';
+import { sha256Utf8 } from '../common/sha256.js';
+import { isCanonicalExactMoney } from './financialValidationPrimitives.js';
+import { isFinancialChargeInclusionPolicyRefV1 } from './financialChargeCompositionValidation.js';
+import { FINANCIAL_POLICY_DEFINITION_CONTRACT_VERSION_V1, FINANCIAL_POLICY_EVALUATION_CONTRACT_VERSION_V1, } from './financialPolicy.js';
+import { FINANCIAL_DATAFLOW_LIMITS_V1, canonicalizeFinancialDataflowJsonV1, canonicalizeFinancialDataflowCoordinateV1, hasFinancialDataflowExactFieldsV1, isFinancialDataflowCurrencyV1, createFinancialDataflowCoordinateIdV1, isFinancialDataflowHashV1, isFinancialDataflowIdentityV1, isFinancialDataflowIsoInstantV1, isFinancialDataflowRecordV1, isFinancialDataflowScopeSelectorV1, isFinancialDataflowSortedUniqueStringsV1, isFinancialDataflowValueWithinLimitsV1, } from './financialDataflowValidation.js';
+import { isCurrentSpendCompositionV1 } from './financialDataflowValidation.js';
+import { isFinancialAnalyticsProjectionV1 } from './financialAnalyticsValidation.js';
+const COST_BASES = new Set(['billed', 'amortized']);
+const ESTIMATE_LENSES = new Set(['billing-only', 'include-estimates', 'estimates-only']);
+const MATCHED_THRESHOLD_KINDS = new Set(['amount', 'percent', 'minimum-amount', 'minimum-delta', 'minimum-percent-change']);
+const MAX_THRESHOLDS = 64;
+const MAX_DESTINATIONS = 256;
+const isCanonicalPolicyRevision = (value) => {
+    if (typeof value !== 'string' || !/^[1-9]\d*$/.test(value))
+        return false;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && String(parsed) === value;
+};
+const isCanonicalDecimal = (value) => typeof value === 'string' && isCanonicalExactMoney({ amount: value, currencyCode: 'AUD' });
+const isNonNegativeDecimal = (value) => {
+    if (!isCanonicalDecimal(value))
+        return false;
+    try {
+        return parseCanonicalDecimal(value).coefficient >= 0n;
+    }
+    catch {
+        return false;
+    }
+};
+const compareCanonicalDecimals = (left, right) => {
+    const difference = subtractExactDecimalValues(parseCanonicalDecimal(left), parseCanonicalDecimal(right)).coefficient;
+    return difference < 0n ? -1 : difference > 0n ? 1 : 0;
+};
+const isPercentageThresholdMatched = (amount, denominator, threshold) => {
+    const parsedDenominator = parseCanonicalDecimal(denominator);
+    if (parsedDenominator.coefficient <= 0n)
+        return false;
+    const scaledAmount = multiplyExactDecimalValues(parseCanonicalDecimal(amount), parseCanonicalDecimal('100'));
+    const scaledThreshold = multiplyExactDecimalValues(parsedDenominator, parseCanonicalDecimal(threshold));
+    return subtractExactDecimalValues(scaledAmount, scaledThreshold).coefficient >= 0n;
+};
+const isThresholdSet = (value) => {
+    if (!isFinancialDataflowRecordV1(value) ||
+        !hasFinancialDataflowExactFieldsV1(value, ['amounts', 'percents']) ||
+        !Array.isArray(value.amounts) ||
+        !Array.isArray(value.percents) ||
+        value.amounts.length + value.percents.length === 0 ||
+        value.amounts.length + value.percents.length > MAX_THRESHOLDS ||
+        !value.amounts.every(isNonNegativeDecimal) ||
+        !value.percents.every(isNonNegativeDecimal)) {
+        return false;
+    }
+    return new Set(value.amounts).size === value.amounts.length && new Set(value.percents).size === value.percents.length;
+};
+const isScopeSelectorBoundToProviderAccounts = (selector, providerAccountRefs) => {
+    if (!isFinancialDataflowScopeSelectorV1(selector) || !Array.isArray(providerAccountRefs))
+        return false;
+    const providerSubscriptions = providerAccountRefs.map(value => {
+        if (typeof value !== 'string' || !value.toLowerCase().startsWith('azure-subscription:'))
+            return undefined;
+        const subscriptionId = value.slice('azure-subscription:'.length).trim().toLowerCase();
+        return subscriptionId || undefined;
+    });
+    if (providerSubscriptions.some(value => value === undefined))
+        return false;
+    const authorized = new Set(providerSubscriptions);
+    if (selector.kind === 'subscription' || selector.kind === 'multi-subscription') {
+        const selected = selector.subscriptionIds.map(value => value.trim().toLowerCase());
+        return selected.length === authorized.size && selected.every(value => authorized.has(value));
+    }
+    if (selector.kind === 'tag-scope')
+        return true;
+    const ids = selector.kind === 'resource' ? selector.resourceIds : selector.resourceGroupIds;
+    return ids.every(value => {
+        const match = /^\/subscriptions\/([^/]+)(?:\/|$)/i.exec(value.trim());
+        return match?.[1] !== undefined && authorized.has(match[1].toLowerCase());
+    });
+};
+const isCoordinateRequest = (value, companyId) => isFinancialDataflowRecordV1(value) &&
+    hasFinancialDataflowExactFieldsV1(value, [
+        'provider',
+        'providerAccountRefs',
+        'scope',
+        'scopeSelector',
+        'period',
+        'costBasis',
+        'estimateLens',
+        'chargeInclusionPolicyRef',
+        'requiredAccountingCurrencyCode',
+    ]) &&
+    value.provider === 'azure' &&
+    isFinancialDataflowSortedUniqueStringsV1(value.providerAccountRefs, FINANCIAL_DATAFLOW_LIMITS_V1.maximumProviderAccounts) &&
+    value.providerAccountRefs.length > 0 &&
+    isFinancialDataflowRecordV1(value.scope) &&
+    hasFinancialDataflowExactFieldsV1(value.scope, ['kind', 'scopeId']) &&
+    ['resource', 'resource-group', 'subscription', 'tag-scope', 'multi-subscription'].includes(String(value.scope.kind)) &&
+    isFinancialDataflowIdentityV1(value.scope.scopeId) &&
+    isFinancialDataflowScopeSelectorV1(value.scopeSelector) &&
+    value.scopeSelector.kind === value.scope.kind &&
+    isScopeSelectorBoundToProviderAccounts(value.scopeSelector, value.providerAccountRefs) &&
+    isFinancialDataflowRecordV1(value.period) &&
+    hasFinancialDataflowExactFieldsV1(value.period, ['kind', 'dateBasis'], ['timeZone']) &&
+    (value.period.kind === 'calendar-month' || value.period.kind === 'rolling-30-days') &&
+    (value.period.dateBasis === 'utc'
+        ? value.period.timeZone === undefined
+        : value.period.dateBasis === 'company-local' && isFinancialDataflowIdentityV1(value.period.timeZone)) &&
+    typeof value.costBasis === 'string' &&
+    COST_BASES.has(value.costBasis) &&
+    typeof value.estimateLens === 'string' &&
+    ESTIMATE_LENSES.has(value.estimateLens) &&
+    isFinancialChargeInclusionPolicyRefV1(value.chargeInclusionPolicyRef) &&
+    isFinancialDataflowCurrencyV1(value.requiredAccountingCurrencyCode) &&
+    isFinancialDataflowIdentityV1(companyId);
+const isCriteria = (value, currencyCode) => {
+    if (!isFinancialDataflowRecordV1(value))
+        return false;
+    if (value.kind === 'budget') {
+        return (hasFinancialDataflowExactFieldsV1(value, ['kind', 'budget'], ['currentSpendThresholds', 'forecastThresholds']) &&
+            isCanonicalExactMoney(value.budget) &&
+            isNonNegativeDecimal(value.budget.amount) &&
+            value.budget.currencyCode === currencyCode &&
+            (value.currentSpendThresholds !== undefined || value.forecastThresholds !== undefined) &&
+            (value.currentSpendThresholds === undefined || isThresholdSet(value.currentSpendThresholds)) &&
+            (value.forecastThresholds === undefined || isThresholdSet(value.forecastThresholds)));
+    }
+    return (value.kind === 'cost-anomaly' &&
+        hasFinancialDataflowExactFieldsV1(value, ['kind'], ['minimumAmount', 'minimumDelta', 'minimumPercentChange']) &&
+        (value.minimumAmount !== undefined || value.minimumDelta !== undefined || value.minimumPercentChange !== undefined) &&
+        (value.minimumAmount === undefined || isNonNegativeDecimal(value.minimumAmount)) &&
+        (value.minimumDelta === undefined || isNonNegativeDecimal(value.minimumDelta)) &&
+        (value.minimumPercentChange === undefined || isNonNegativeDecimal(value.minimumPercentChange)));
+};
+export const isFinancialPolicyDefinitionRevisionIdentityPreimageV1 = (value) => {
+    if (!isFinancialDataflowRecordV1(value) ||
+        !hasFinancialDataflowExactFieldsV1(value, [
+            'schemaVersion',
+            'contractVersion',
+            'companyId',
+            'definitionId',
+            'displayName',
+            'revision',
+            'effectiveState',
+            'coordinateRequest',
+            'criteria',
+            'schedule',
+            'destinationRefIds',
+            'destinationsDigest',
+            'authoredAt',
+            'authoredByUserId',
+        ]) ||
+        value.schemaVersion !== 1 ||
+        value.contractVersion !== FINANCIAL_POLICY_DEFINITION_CONTRACT_VERSION_V1 ||
+        !isFinancialDataflowIdentityV1(value.companyId) ||
+        !isFinancialDataflowIdentityV1(value.definitionId) ||
+        !isFinancialDataflowIdentityV1(value.displayName) ||
+        !isCanonicalPolicyRevision(value.revision) ||
+        !['enabled', 'disabled', 'deleted'].includes(String(value.effectiveState)) ||
+        !isCoordinateRequest(value.coordinateRequest, value.companyId) ||
+        !isFinancialDataflowRecordV1(value.coordinateRequest) ||
+        !isCriteria(value.criteria, String(value.coordinateRequest.requiredAccountingCurrencyCode)) ||
+        !isFinancialDataflowRecordV1(value.schedule) ||
+        !hasFinancialDataflowExactFieldsV1(value.schedule, ['cadenceMinutes']) ||
+        !Number.isSafeInteger(value.schedule.cadenceMinutes) ||
+        Number(value.schedule.cadenceMinutes) < 1 ||
+        Number(value.schedule.cadenceMinutes) > 10080 ||
+        !isFinancialDataflowSortedUniqueStringsV1(value.destinationRefIds, MAX_DESTINATIONS) ||
+        !isFinancialDataflowHashV1(value.destinationsDigest) ||
+        !isFinancialDataflowIsoInstantV1(value.authoredAt) ||
+        !isFinancialDataflowIdentityV1(value.authoredByUserId)) {
+        return false;
+    }
+    if (value.criteria.kind === 'budget' &&
+        value.criteria.forecastThresholds !== undefined &&
+        (value.coordinateRequest.period.kind !== 'calendar-month' || value.coordinateRequest.estimateLens !== 'billing-only')) {
+        return false;
+    }
+    if (value.criteria.kind === 'cost-anomaly' &&
+        (value.coordinateRequest.period.kind !== 'rolling-30-days' || value.coordinateRequest.estimateLens !== 'billing-only')) {
+        return false;
+    }
+    // Alert Instance state is the canonical internal policy side effect.
+    // External destinations are optional and must not determine whether an
+    // enabled policy is valid or evaluable.
+    return true;
+};
+export const canonicalizeFinancialPolicyDefinitionRevisionIdentityV1 = (value) => {
+    if (!isFinancialDataflowValueWithinLimitsV1(value) || !isFinancialPolicyDefinitionRevisionIdentityPreimageV1(value)) {
+        throw new TypeError('Invalid FinancialPolicyDefinitionRevisionIdentityPreimageV1.');
+    }
+    const criteria = value.criteria.kind === 'budget'
+        ? {
+            ...value.criteria,
+            ...(value.criteria.currentSpendThresholds === undefined
+                ? {}
+                : {
+                    currentSpendThresholds: {
+                        amounts: [...value.criteria.currentSpendThresholds.amounts].sort(),
+                        percents: [...value.criteria.currentSpendThresholds.percents].sort(),
+                    },
+                }),
+            ...(value.criteria.forecastThresholds === undefined
+                ? {}
+                : {
+                    forecastThresholds: {
+                        amounts: [...value.criteria.forecastThresholds.amounts].sort(),
+                        percents: [...value.criteria.forecastThresholds.percents].sort(),
+                    },
+                }),
+        }
+        : value.criteria;
+    return canonicalizeFinancialDataflowJsonV1({
+        ...value,
+        coordinateRequest: {
+            ...value.coordinateRequest,
+            providerAccountRefs: [...value.coordinateRequest.providerAccountRefs].sort(),
+        },
+        criteria,
+        destinationRefIds: [...value.destinationRefIds].sort(),
+    });
+};
+export const createFinancialPolicyDefinitionRevisionIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialPolicyDefinitionRevisionIdentityV1(value))}`;
+export const isFinancialPolicyDefinitionRevisionV1 = (value) => {
+    if (!isFinancialDataflowValueWithinLimitsV1(value) ||
+        !isFinancialDataflowRecordV1(value) ||
+        !Object.prototype.hasOwnProperty.call(value, 'policyDefinitionRevisionId'))
+        return false;
+    const { policyDefinitionRevisionId, ...identity } = value;
+    return (isFinancialDataflowHashV1(policyDefinitionRevisionId) &&
+        isFinancialPolicyDefinitionRevisionIdentityPreimageV1(identity) &&
+        policyDefinitionRevisionId === createFinancialPolicyDefinitionRevisionIdV1(identity));
+};
+const isMatchedThresholds = (value) => Array.isArray(value) &&
+    value.length <= MAX_THRESHOLDS &&
+    value.every(threshold => isFinancialDataflowRecordV1(threshold) &&
+        hasFinancialDataflowExactFieldsV1(threshold, ['thresholdKind', 'configuredValue']) &&
+        typeof threshold.thresholdKind === 'string' &&
+        MATCHED_THRESHOLD_KINDS.has(threshold.thresholdKind) &&
+        isNonNegativeDecimal(threshold.configuredValue)) &&
+    new Set(value.map(threshold => `${String(threshold.thresholdKind)}\u0000${String(threshold.configuredValue)}`)).size === value.length;
+const isEvaluationIdentity = (value) => {
+    if (!isFinancialDataflowRecordV1(value) ||
+        !hasFinancialDataflowExactFieldsV1(value, [
+            'schemaVersion',
+            'contractVersion',
+            'companyId',
+            'policyDefinitionRevisionId',
+            'definitionId',
+            'definitionRevision',
+            'coordinateId',
+            'currentSpendCompositionId',
+            'signalKind',
+            'evaluatedAt',
+            'policyAlgorithmVersion',
+            'result',
+            'reasonCode',
+            'matchedThresholds',
+        ], ['analyticsProjectionId']) ||
+        value.schemaVersion !== 1 ||
+        value.contractVersion !== FINANCIAL_POLICY_EVALUATION_CONTRACT_VERSION_V1 ||
+        !isFinancialDataflowIdentityV1(value.companyId) ||
+        !isFinancialDataflowHashV1(value.policyDefinitionRevisionId) ||
+        !isFinancialDataflowIdentityV1(value.definitionId) ||
+        !isFinancialDataflowIdentityV1(value.definitionRevision) ||
+        !isFinancialDataflowHashV1(value.coordinateId) ||
+        !isFinancialDataflowHashV1(value.currentSpendCompositionId) ||
+        !['budget-current-spend', 'budget-forecast', 'cost-anomaly'].includes(String(value.signalKind)) ||
+        !isFinancialDataflowIsoInstantV1(value.evaluatedAt) ||
+        !isFinancialDataflowIdentityV1(value.policyAlgorithmVersion) ||
+        !['matched', 'not-matched', 'partial', 'unavailable'].includes(String(value.result)) ||
+        !isFinancialDataflowIdentityV1(value.reasonCode) ||
+        !isMatchedThresholds(value.matchedThresholds)) {
+        return false;
+    }
+    const analyticsSignal = value.signalKind === 'budget-forecast' || value.signalKind === 'cost-anomaly';
+    if (!analyticsSignal)
+        return value.analyticsProjectionId === undefined;
+    if (value.result !== 'unavailable')
+        return isFinancialDataflowHashV1(value.analyticsProjectionId);
+    return value.analyticsProjectionId === undefined || isFinancialDataflowHashV1(value.analyticsProjectionId);
+};
+export const canonicalizeFinancialPolicyEvaluationIdentityV1 = (value) => {
+    if (!isFinancialDataflowValueWithinLimitsV1(value) || !isEvaluationIdentity(value)) {
+        throw new TypeError('Invalid FinancialPolicyEvaluationIdentityPreimageV1.');
+    }
+    return canonicalizeFinancialDataflowJsonV1({
+        ...value,
+        matchedThresholds: [...value.matchedThresholds].sort((left, right) => `${left.thresholdKind}\u0000${left.configuredValue}`.localeCompare(`${right.thresholdKind}\u0000${right.configuredValue}`)),
+    });
+};
+export const createFinancialPolicyEvaluationIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialPolicyEvaluationIdentityV1(value))}`;
+export const createFinancialPolicyEvaluationReadProjectionIdV1 = (evaluationId) => {
+    if (!isFinancialDataflowHashV1(evaluationId))
+        throw new TypeError('Invalid evaluationId.');
+    return `${evaluationId}:read`;
+};
+export const createFinancialPolicyEvaluationActionAuditIdV1 = (evaluationId) => {
+    if (!isFinancialDataflowHashV1(evaluationId))
+        throw new TypeError('Invalid evaluationId.');
+    return `${evaluationId}:action`;
+};
+export const isFinancialPolicyEvaluationV1 = (value) => {
+    if (!isFinancialDataflowValueWithinLimitsV1(value) ||
+        !isFinancialDataflowRecordV1(value) ||
+        !hasFinancialDataflowExactFieldsV1(value, [
+            'schemaVersion',
+            'contractVersion',
+            'evaluationId',
+            'companyId',
+            'policyDefinitionRevisionId',
+            'definitionId',
+            'definitionRevision',
+            'coordinateId',
+            'currentSpendCompositionId',
+            'signalKind',
+            'evaluatedAt',
+            'policyAlgorithmVersion',
+            'result',
+            'reasonCode',
+            'matchedThresholds',
+            'readProjectionId',
+            'actionAuditId',
+        ], ['analyticsProjectionId'])) {
+        return false;
+    }
+    const { evaluationId, readProjectionId, actionAuditId, ...identity } = value;
+    return (isFinancialDataflowHashV1(evaluationId) &&
+        isEvaluationIdentity(identity) &&
+        evaluationId === createFinancialPolicyEvaluationIdV1(identity) &&
+        readProjectionId === createFinancialPolicyEvaluationReadProjectionIdV1(evaluationId) &&
+        actionAuditId === createFinancialPolicyEvaluationActionAuditIdV1(evaluationId));
+};
+const sameStrings = (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 thresholdKey = (threshold) => `${threshold.thresholdKind}\u0000${threshold.configuredValue}`;
+const hasExactMatchedThresholds = (actual, expected) => {
+    if (actual.length !== expected.length)
+        return false;
+    const expectedKeys = new Set(expected.map(thresholdKey));
+    return actual.every(threshold => expectedKeys.has(thresholdKey(threshold)));
+};
+const budgetMatchedThresholds = (amount, budget, thresholds) => [
+    ...thresholds.amounts
+        .filter(threshold => compareCanonicalDecimals(amount, threshold) >= 0)
+        .map(configuredValue => ({ thresholdKind: 'amount', configuredValue })),
+    ...thresholds.percents
+        .filter(threshold => isPercentageThresholdMatched(amount, budget, threshold))
+        .map(configuredValue => ({ thresholdKind: 'percent', configuredValue })),
+];
+const safeBudgetMatchedThresholds = (amount, budget, thresholds) => {
+    try {
+        return budgetMatchedThresholds(amount, budget, thresholds);
+    }
+    catch {
+        return undefined;
+    }
+};
+const anomalyMatchedThresholds = (definition, analyticsProjection) => {
+    if (definition.criteria.kind !== 'cost-anomaly' || analyticsProjection.status === 'unavailable' || analyticsProjection.result.kind !== 'anomaly') {
+        return [];
+    }
+    const configured = [
+        ...(definition.criteria.minimumAmount === undefined
+            ? []
+            : [{ thresholdKind: 'minimum-amount', configuredValue: definition.criteria.minimumAmount }]),
+        ...(definition.criteria.minimumDelta === undefined
+            ? []
+            : [{ thresholdKind: 'minimum-delta', configuredValue: definition.criteria.minimumDelta }]),
+        ...(definition.criteria.minimumPercentChange === undefined
+            ? []
+            : [{ thresholdKind: 'minimum-percent-change', configuredValue: definition.criteria.minimumPercentChange }]),
+    ];
+    const matched = analyticsProjection.result.events.some(event => configured.every(threshold => {
+        if (threshold.thresholdKind === 'minimum-amount')
+            return compareCanonicalDecimals(event.observed.amount, threshold.configuredValue) >= 0;
+        if (threshold.thresholdKind === 'minimum-delta')
+            return compareCanonicalDecimals(event.delta.amount, threshold.configuredValue) >= 0;
+        return isPercentageThresholdMatched(event.delta.amount, event.expected.amount, threshold.configuredValue);
+    }));
+    return matched ? configured : [];
+};
+const safeAnomalyMatchedThresholds = (definition, analyticsProjection) => {
+    try {
+        return anomalyMatchedThresholds(definition, analyticsProjection);
+    }
+    catch {
+        return undefined;
+    }
+};
+const isExpectedCalendarMonthTargetPartial = (composition) => composition.coordinate.period.windowKind === 'calendar-month' &&
+    composition.amount.status === 'partial' &&
+    composition.amount.reasonCodes.length === 1 &&
+    composition.amount.reasonCodes[0] === 'coverage-incomplete';
+/** Validates definition, coordinate, financial input, and signal links after authorization. */
+export const isFinancialPolicyEvaluationCompatibleV1 = (evaluation, definition, currentSpendComposition, analyticsProjection) => {
+    if (!isFinancialPolicyEvaluationV1(evaluation) ||
+        !isFinancialPolicyDefinitionRevisionV1(definition) ||
+        !isCurrentSpendCompositionV1(currentSpendComposition)) {
+        return false;
+    }
+    const coordinate = currentSpendComposition.coordinate;
+    const request = definition.coordinateRequest;
+    const currency = coordinate.accountingCurrency.status === 'resolved' ? coordinate.accountingCurrency.currencyCode : undefined;
+    const periodTimeZone = coordinate.period.requested.timeZone;
+    if (definition.effectiveState !== 'enabled' ||
+        evaluation.companyId !== definition.companyId ||
+        evaluation.companyId !== coordinate.companyId ||
+        evaluation.policyDefinitionRevisionId !== definition.policyDefinitionRevisionId ||
+        evaluation.definitionId !== definition.definitionId ||
+        evaluation.definitionRevision !== definition.revision ||
+        evaluation.coordinateId !== createFinancialDataflowCoordinateIdV1(coordinate) ||
+        evaluation.currentSpendCompositionId !== currentSpendComposition.compositionId ||
+        request.provider !== coordinate.provider ||
+        !sameStrings(request.providerAccountRefs, coordinate.providerAccountRefs) ||
+        request.scope.kind !== coordinate.scope.kind ||
+        request.scope.scopeId !== coordinate.scope.scopeId ||
+        request.costBasis !== coordinate.costBasis ||
+        request.estimateLens !== coordinate.estimateLens ||
+        canonicalizeFinancialDataflowJsonV1(request.chargeInclusionPolicyRef) !==
+            canonicalizeFinancialDataflowJsonV1(coordinate.chargeInclusionPolicyRef) ||
+        coordinate.requestedCurrencyCode !== request.requiredAccountingCurrencyCode ||
+        (currency === undefined
+            ? currentSpendComposition.amount.status !== 'unavailable'
+            : request.requiredAccountingCurrencyCode !== currency) ||
+        request.period.kind !== coordinate.period.windowKind ||
+        request.period.dateBasis !== coordinate.period.requested.dateBasis ||
+        (request.period.dateBasis === 'company-local' && request.period.timeZone !== periodTimeZone)) {
+        return false;
+    }
+    if (evaluation.result === 'matched' ? evaluation.matchedThresholds.length === 0 : evaluation.matchedThresholds.length > 0)
+        return false;
+    let configuredAmounts = [];
+    let configuredPercents = [];
+    if (evaluation.signalKind === 'budget-current-spend' || evaluation.signalKind === 'budget-forecast') {
+        if (definition.criteria.kind !== 'budget')
+            return false;
+        const thresholds = evaluation.signalKind === 'budget-current-spend' ? definition.criteria.currentSpendThresholds : definition.criteria.forecastThresholds;
+        if (thresholds === undefined)
+            return false;
+        configuredAmounts = thresholds.amounts;
+        configuredPercents = thresholds.percents;
+    }
+    else {
+        if (definition.criteria.kind !== 'cost-anomaly')
+            return false;
+    }
+    for (const threshold of evaluation.matchedThresholds) {
+        if (threshold.thresholdKind === 'amount' && !configuredAmounts.includes(threshold.configuredValue))
+            return false;
+        if (threshold.thresholdKind === 'percent' && !configuredPercents.includes(threshold.configuredValue))
+            return false;
+        if (threshold.thresholdKind === 'minimum-amount' &&
+            (definition.criteria.kind !== 'cost-anomaly' || threshold.configuredValue !== definition.criteria.minimumAmount))
+            return false;
+        if (threshold.thresholdKind === 'minimum-delta' &&
+            (definition.criteria.kind !== 'cost-anomaly' || threshold.configuredValue !== definition.criteria.minimumDelta))
+            return false;
+        if (threshold.thresholdKind === 'minimum-percent-change' &&
+            (definition.criteria.kind !== 'cost-anomaly' || threshold.configuredValue !== definition.criteria.minimumPercentChange))
+            return false;
+    }
+    if (evaluation.signalKind === 'budget-current-spend') {
+        if (evaluation.analyticsProjectionId !== undefined || analyticsProjection !== undefined)
+            return false;
+        if (currentSpendComposition.amount.status === 'unavailable') {
+            return evaluation.result === 'unavailable' && evaluation.matchedThresholds.length === 0;
+        }
+        if (currentSpendComposition.amount.status === 'partial') {
+            if (!isExpectedCalendarMonthTargetPartial(currentSpendComposition)) {
+                return evaluation.result === 'partial' && evaluation.matchedThresholds.length === 0;
+            }
+            if (definition.criteria.kind !== 'budget' || definition.criteria.currentSpendThresholds === undefined)
+                return false;
+            const expectedThresholds = safeBudgetMatchedThresholds(currentSpendComposition.amount.knownAmount, definition.criteria.budget.amount, definition.criteria.currentSpendThresholds);
+            if (expectedThresholds === undefined)
+                return false;
+            return (evaluation.result === (expectedThresholds.length > 0 ? 'matched' : 'not-matched') &&
+                hasExactMatchedThresholds(evaluation.matchedThresholds, expectedThresholds));
+        }
+        if (definition.criteria.kind !== 'budget' || definition.criteria.currentSpendThresholds === undefined)
+            return false;
+        const expectedThresholds = safeBudgetMatchedThresholds(currentSpendComposition.amount.amount, definition.criteria.budget.amount, definition.criteria.currentSpendThresholds);
+        if (expectedThresholds === undefined)
+            return false;
+        return (evaluation.result === (expectedThresholds.length > 0 ? 'matched' : 'not-matched') &&
+            hasExactMatchedThresholds(evaluation.matchedThresholds, expectedThresholds));
+    }
+    if (evaluation.result === 'unavailable' &&
+        evaluation.analyticsProjectionId === undefined &&
+        analyticsProjection === undefined &&
+        (evaluation.signalKind === 'budget-forecast' || evaluation.signalKind === 'cost-anomaly')) {
+        return evaluation.matchedThresholds.length === 0 && evaluation.reasonCode === 'analytics-projection-unavailable';
+    }
+    if (!isFinancialAnalyticsProjectionV1(analyticsProjection) ||
+        evaluation.analyticsProjectionId !== analyticsProjection.analyticsProjectionId ||
+        analyticsProjection.coordinate.companyId !== coordinate.companyId ||
+        analyticsProjection.coordinate.scope.scopeFingerprint !== coordinate.scope.scopeFingerprint ||
+        analyticsProjection.coordinate.costBasis !== coordinate.costBasis ||
+        analyticsProjection.coordinate.estimateLens !== coordinate.estimateLens ||
+        canonicalizeFinancialDataflowCoordinateV1({ ...analyticsProjection.coordinate, periodRole: 'current-spend' }) !==
+            canonicalizeFinancialDataflowCoordinateV1(coordinate) ||
+        analyticsProjection.coordinate.accountingCurrency.status !== 'resolved' ||
+        analyticsProjection.coordinate.accountingCurrency.currencyCode !== currency) {
+        return false;
+    }
+    const expectedAnalyticsKind = evaluation.signalKind === 'budget-forecast' ? 'forecast' : 'anomaly';
+    const actualAnalyticsKind = analyticsProjection.status === 'unavailable' ? analyticsProjection.resultKind : analyticsProjection.result.kind;
+    if (actualAnalyticsKind !== expectedAnalyticsKind)
+        return false;
+    if (analyticsProjection.currentSpendCompositionId !== undefined &&
+        analyticsProjection.currentSpendCompositionId !== currentSpendComposition.compositionId) {
+        return false;
+    }
+    if (evaluation.signalKind === 'budget-forecast' &&
+        analyticsProjection.status !== 'unavailable' &&
+        analyticsProjection.currentSpendCompositionId !== currentSpendComposition.compositionId) {
+        return false;
+    }
+    if (currentSpendComposition.amount.status === 'unavailable' || analyticsProjection.status === 'unavailable') {
+        return evaluation.result === 'unavailable' && evaluation.matchedThresholds.length === 0;
+    }
+    if (analyticsProjection.status === 'partial' ||
+        (currentSpendComposition.amount.status === 'partial' &&
+            !(evaluation.signalKind === 'budget-forecast' && isExpectedCalendarMonthTargetPartial(currentSpendComposition)))) {
+        return evaluation.result === 'partial' && evaluation.matchedThresholds.length === 0;
+    }
+    if (evaluation.result !== 'matched' && evaluation.result !== 'not-matched')
+        return false;
+    if (evaluation.signalKind === 'budget-forecast') {
+        if (definition.criteria.kind !== 'budget' ||
+            definition.criteria.forecastThresholds === undefined ||
+            analyticsProjection.result.kind !== 'forecast') {
+            return false;
+        }
+        const expectedThresholds = safeBudgetMatchedThresholds(analyticsProjection.result.projectedTotal.amount, definition.criteria.budget.amount, definition.criteria.forecastThresholds);
+        if (expectedThresholds === undefined)
+            return false;
+        return (evaluation.result === (expectedThresholds.length > 0 ? 'matched' : 'not-matched') &&
+            hasExactMatchedThresholds(evaluation.matchedThresholds, expectedThresholds));
+    }
+    if (analyticsProjection.result.kind !== 'anomaly')
+        return false;
+    const expectedThresholds = safeAnomalyMatchedThresholds(definition, analyticsProjection);
+    if (expectedThresholds === undefined)
+        return false;
+    return (evaluation.result === (expectedThresholds.length > 0 ? 'matched' : 'not-matched') &&
+        hasExactMatchedThresholds(evaluation.matchedThresholds, expectedThresholds));
+};

package/dist/esm/azure/financialProjection.js

@@ -0,0 +1,14 @@
+export const FINANCIAL_PROJECTION_SCHEMA_VERSION_V1 = 1;
+export const FINANCIAL_PROJECTION_CONTRACT_VERSION_V1 = 'financial-projection/v1';
+export const FINANCIAL_PROJECTION_UNAVAILABLE_REASONS_V1 = [
+    'baseline-unavailable',
+    'affected-component-not-found',
+    'target-evidence-unavailable',
+    'target-period-incompatible',
+    'target-basis-incompatible',
+    'target-currency-conflicting',
+    'quantity-unavailable',
+    'rate-unavailable',
+    'reconciliation-failure',
+    'unsupported-operation',
+];