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

package/dist/esm/azure/financialEligibilityAssessmentValidation.js

@@ -0,0 +1,176 @@
+import { formatExactDecimalValue, sumCanonicalDecimals } from '../common/exactDecimal.js';
+import { sha256Utf8 } from '../common/sha256.js';
+import { FINANCIAL_ELIGIBILITY_ASSESSMENT_CONTRACT_VERSION_V1, FINANCIAL_ELIGIBILITY_ASSESSMENT_SCHEMA_VERSION_V1, } from './financialSavingsAuthority.js';
+import { createFinancialSavingsDenominatorIdV1 } from './financialSavingsCoordinateValidation.js';
+import { isFinancialScopeBaselineEnvelopeV2 } from './financialScopeBaselineValidation.js';
+import { canonicalizeFinancialSavingsJsonValue, hasExactFinancialSavingsFields, haveSameFinancialSavingsSet, isFinancialSavingsHash, isFinancialSavingsIdentity, isFinancialSavingsIsoInstant, isFinancialSavingsRecord, } from './financialSavingsAuthorityValidationPrimitives.js';
+const BENEFIT_KINDS = new Set(['savings-plan', 'reservation', 'licence', 'other']);
+const UNAVAILABLE_REASONS = new Set([
+    'rule-evidence-unavailable',
+    'eligibility-baseline-unavailable',
+    'eligible-components-unavailable',
+    'denominator-unavailable',
+    'current-baseline-mapping-unavailable',
+    'currency-conflict',
+    'reconciliation-failure',
+]);
+export const canonicalizeFinancialEligibilityAssessmentIdentityV1 = (value) => JSON.stringify(canonicalizeFinancialSavingsJsonValue(value.status === 'unavailable'
+    ? { ...value, providerAccountRefs: [...value.providerAccountRefs].sort() }
+    : {
+        ...value,
+        providerAccountRefs: [...value.providerAccountRefs].sort(),
+        denominator: { ...value.denominator, componentIds: [...value.denominator.componentIds].sort() },
+        eligibleComponentIds: [...value.eligibleComponentIds].sort(),
+        excludedComponentIds: [...value.excludedComponentIds].sort(),
+        currentBaselineMapping: {
+            ...value.currentBaselineMapping,
+            mappings: [...value.currentBaselineMapping.mappings]
+                .sort((left, right) => left.currentComponentId.localeCompare(right.currentComponentId))
+                .map(mapping => ({ ...mapping, eligibilityComponentIds: [...mapping.eligibilityComponentIds].sort() })),
+        },
+    }));
+export const createFinancialEligibilityAssessmentIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialEligibilityAssessmentIdentityV1(value))}`;
+export const validateFinancialEligibilityBaselineV1 = (value, context) => {
+    if (!isFinancialScopeBaselineEnvelopeV2(value) || value.status !== 'available' || value.baselineKind !== 'owner')
+        return false;
+    if (value.scopeKind === 'subscription-residual')
+        return false;
+    const assessment = context.assessmentById.get(value.assessmentId);
+    return (haveSameFinancialSavingsSet(value.providerAccountRefs, context.authority.providerAccountRefs) &&
+        context.bundleById.has(value.evidenceBundleId) &&
+        assessment?.result === 'available' &&
+        assessment.request.scopeId === value.scopeId &&
+        assessment.evidenceBundleId === value.evidenceBundleId &&
+        assessment.roleAssessments.some(role => role.role === 'eligibility-rule' && role.matchState === 'matched' && role.evidenceRefId !== undefined));
+};
+export const validateFinancialEligibilityAssessmentV1 = (value, context, baselineById) => {
+    if (!isFinancialSavingsRecord(value) ||
+        !hasExactFinancialSavingsFields(value, [
+            'schemaVersion',
+            'contractVersion',
+            'eligibilityId',
+            'provider',
+            'providerAccountRefs',
+            'scopeId',
+            'scenarioId',
+            'benefitKind',
+            'ruleVersion',
+            'evaluatedAt',
+            'status',
+        ], value.status === 'available'
+            ? ['ruleEvidenceRefId', 'eligibilityBaselineId', 'denominator', 'eligibleComponentIds', 'excludedComponentIds', 'currentBaselineMapping']
+            : ['ruleEvidenceRefId', 'unavailableReason', 'eligibilityBaselineId']) ||
+        value.schemaVersion !== FINANCIAL_ELIGIBILITY_ASSESSMENT_SCHEMA_VERSION_V1 ||
+        value.contractVersion !== FINANCIAL_ELIGIBILITY_ASSESSMENT_CONTRACT_VERSION_V1 ||
+        !isFinancialSavingsHash(value.eligibilityId) ||
+        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 ||
+        !haveSameFinancialSavingsSet(value.providerAccountRefs, context.authority.providerAccountRefs) ||
+        !isFinancialSavingsIdentity(value.scopeId) ||
+        !isFinancialSavingsIdentity(value.scenarioId) ||
+        typeof value.benefitKind !== 'string' ||
+        !BENEFIT_KINDS.has(value.benefitKind) ||
+        !isFinancialSavingsIdentity(value.ruleVersion) ||
+        !isFinancialSavingsIsoInstant(value.evaluatedAt) ||
+        Date.parse(value.evaluatedAt) > Date.parse(context.authority.artifactGeneration.generatedAt))
+        return false;
+    if (value.status === 'unavailable') {
+        const ruleEvidence = typeof value.ruleEvidenceRefId === 'string' ? context.evidenceById.get(value.ruleEvidenceRefId) : undefined;
+        if (typeof value.unavailableReason !== 'string' ||
+            !UNAVAILABLE_REASONS.has(value.unavailableReason) ||
+            (value.ruleEvidenceRefId !== undefined && (!isFinancialSavingsHash(value.ruleEvidenceRefId) || ruleEvidence?.role !== 'eligibility-rule')) ||
+            (value.ruleEvidenceRefId === undefined && value.unavailableReason !== 'rule-evidence-unavailable') ||
+            (value.eligibilityBaselineId !== undefined && !isFinancialSavingsHash(value.eligibilityBaselineId)))
+            return false;
+        const { eligibilityId: _eligibilityId, ...identity } = value;
+        return value.eligibilityId === createFinancialEligibilityAssessmentIdV1(identity);
+    }
+    if (value.status !== 'available' || !isFinancialSavingsHash(value.ruleEvidenceRefId) || !isFinancialSavingsHash(value.eligibilityBaselineId)) {
+        return false;
+    }
+    const baseline = baselineById.get(value.eligibilityBaselineId);
+    if (!baseline || baseline.scopeId !== value.scopeId || !isFinancialSavingsRecord(value.denominator))
+        return false;
+    const baselineBundle = context.bundleById.get(baseline.evidenceBundleId);
+    const ruleEvidence = baselineBundle?.references.find(reference => reference.evidenceRefId === value.ruleEvidenceRefId);
+    const baselineAssessment = context.assessmentById.get(baseline.assessmentId);
+    if (ruleEvidence?.role !== 'eligibility-rule' ||
+        ruleEvidence.revisionId !== value.ruleVersion ||
+        !baselineAssessment?.roleAssessments.some(role => role.role === 'eligibility-rule' && role.matchState === 'matched' && role.evidenceRefId === value.ruleEvidenceRefId))
+        return false;
+    if (!hasExactFinancialSavingsFields(value.denominator, ['denominatorId', 'kind', 'componentIds', 'amount', 'currencyCode']) ||
+        !isFinancialSavingsHash(value.denominator.denominatorId) ||
+        value.denominator.kind !== 'eligible-spend' ||
+        !Array.isArray(value.denominator.componentIds) ||
+        value.denominator.componentIds.length === 0 ||
+        value.denominator.componentIds.length > 20000 ||
+        !value.denominator.componentIds.every(isFinancialSavingsHash) ||
+        new Set(value.denominator.componentIds).size !== value.denominator.componentIds.length ||
+        typeof value.denominator.amount !== 'string' ||
+        typeof value.denominator.currencyCode !== 'string' ||
+        value.denominator.currencyCode !== baseline.total.currencyCode ||
+        !Array.isArray(value.eligibleComponentIds) ||
+        value.eligibleComponentIds.length === 0 ||
+        value.eligibleComponentIds.length > 20000 ||
+        !value.eligibleComponentIds.every(isFinancialSavingsHash) ||
+        new Set(value.eligibleComponentIds).size !== value.eligibleComponentIds.length ||
+        !Array.isArray(value.excludedComponentIds) ||
+        value.excludedComponentIds.length > 20000 ||
+        !value.excludedComponentIds.every(isFinancialSavingsHash) ||
+        new Set(value.excludedComponentIds).size !== value.excludedComponentIds.length ||
+        !haveSameFinancialSavingsSet(value.denominator.componentIds, value.eligibleComponentIds) ||
+        !haveSameFinancialSavingsSet([...value.eligibleComponentIds, ...value.excludedComponentIds], baseline.components.map(component => component.componentId)) ||
+        !isFinancialSavingsRecord(value.currentBaselineMapping) ||
+        !hasExactFinancialSavingsFields(value.currentBaselineMapping, ['currentBaselineId', 'compatibility', 'mappings']) ||
+        !isFinancialSavingsHash(value.currentBaselineMapping.currentBaselineId) ||
+        value.currentBaselineMapping.compatibility !== 'compatible' ||
+        !Array.isArray(value.currentBaselineMapping.mappings) ||
+        value.currentBaselineMapping.mappings.length === 0 ||
+        value.currentBaselineMapping.mappings.length > 20000)
+        return false;
+    const excludedComponentIds = new Set(value.excludedComponentIds);
+    if (value.eligibleComponentIds.some(componentId => excludedComponentIds.has(componentId)))
+        return false;
+    const baselineComponentById = new Map(baseline.components.map(component => [component.componentId, component]));
+    try {
+        const eligibleAmount = formatExactDecimalValue(sumCanonicalDecimals(value.eligibleComponentIds.map(componentId => baselineComponentById.get(componentId).amount)));
+        if (eligibleAmount !== value.denominator.amount ||
+            value.denominator.denominatorId !==
+                createFinancialSavingsDenominatorIdV1({
+                    kind: 'eligible-spend',
+                    baselineId: baseline.baselineId,
+                    componentIds: [value.denominator.componentIds[0], ...value.denominator.componentIds.slice(1)],
+                    amount: value.denominator.amount,
+                    currencyCode: value.denominator.currencyCode,
+                }))
+            return false;
+    }
+    catch {
+        return false;
+    }
+    const currentComponentIds = [];
+    const mappedEligibilityComponentIds = [];
+    for (const mapping of value.currentBaselineMapping.mappings) {
+        if (!isFinancialSavingsRecord(mapping) ||
+            !hasExactFinancialSavingsFields(mapping, ['currentComponentId', 'eligibilityComponentIds']) ||
+            !isFinancialSavingsHash(mapping.currentComponentId) ||
+            !Array.isArray(mapping.eligibilityComponentIds) ||
+            mapping.eligibilityComponentIds.length === 0 ||
+            mapping.eligibilityComponentIds.length > 20000 ||
+            !mapping.eligibilityComponentIds.every(isFinancialSavingsHash) ||
+            new Set(mapping.eligibilityComponentIds).size !== mapping.eligibilityComponentIds.length)
+            return false;
+        currentComponentIds.push(mapping.currentComponentId);
+        mappedEligibilityComponentIds.push(...mapping.eligibilityComponentIds);
+    }
+    if (new Set(currentComponentIds).size !== currentComponentIds.length ||
+        new Set(mappedEligibilityComponentIds).size !== mappedEligibilityComponentIds.length ||
+        !haveSameFinancialSavingsSet(mappedEligibilityComponentIds, value.eligibleComponentIds))
+        return false;
+    const { eligibilityId: _eligibilityId, ...identity } = value;
+    return value.eligibilityId === createFinancialEligibilityAssessmentIdV1(identity);
+};

package/dist/esm/azure/financialEvidenceAssessmentValidation.js

@@ -0,0 +1,153 @@
+import { sha256Utf8 } from '../common/sha256.js';
+import { FINANCIAL_EVIDENCE_ASSESSMENT_CONTRACT_VERSION_V1, } from './financialScopeEvidence.js';
+import { canonicalizeValidatedFinancialEvidenceAssessmentIdentityV1 } from './financialScopeBaselineIdentity.js';
+const MAX_EVIDENCE_REFERENCES = 64;
+const MAX_IDENTITY_LENGTH = 256;
+const SHA256_ID = /^sha256:[0-9a-f]{64}$/;
+const EVIDENCE_ROLES = new Set([
+    'billing',
+    'billing-currency-declaration',
+    'estimate',
+    'inventory-configuration',
+    'retail-rate',
+    'commitment-quote',
+    'fx-conversion',
+    'eligibility-rule',
+    'recommendation-scenario-set',
+    'recommendation-lifecycle',
+]);
+const SCOPE_KINDS = new Set([
+    'canonical-resource-owner',
+    'composite-resource',
+    'commitment-instrument',
+    'subscription-residual',
+    'subscription-aggregate',
+    'portfolio-currency-group',
+]);
+const ASSESSMENT_REASONS = new Set([
+    'evidence-accepted',
+    'evidence-not-produced',
+    'evidence-not-matched',
+    'evidence-incomplete',
+    'evidence-stale',
+    'reconciliation-failed',
+    'currency-unresolved',
+    'currency-conflicting',
+    'ownership-unresolved',
+    'unsupported-scope',
+]);
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const hasExactFields = (value, required, optional = []) => {
+    const allowed = new Set([...required, ...optional]);
+    const keys = Object.keys(value);
+    return required.every(field => Object.prototype.hasOwnProperty.call(value, field)) && keys.every(field => allowed.has(field));
+};
+const isBoundedIdentity = (value) => typeof value === 'string' && value.length > 0 && value.length <= MAX_IDENTITY_LENGTH && value.trim() === value;
+const isIsoInstant = (value) => typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value) && Number.isFinite(Date.parse(value));
+const isCountSummary = (value) => isRecord(value) &&
+    hasExactFields(value, ['requestedRoleCount', 'producedRoleCount', 'matchedRoleCount']) &&
+    [value.requestedRoleCount, value.producedRoleCount, value.matchedRoleCount].every(count => Number.isSafeInteger(count) && Number(count) >= 0) &&
+    Number(value.matchedRoleCount) <= Number(value.producedRoleCount) &&
+    Number(value.producedRoleCount) <= Number(value.requestedRoleCount);
+const isAssessmentIdentity = (value) => {
+    if (!isRecord(value) ||
+        !hasExactFields(value, [
+            'schemaVersion',
+            'contractVersion',
+            'policyVersion',
+            'evaluatedAt',
+            'request',
+            'roleAssessments',
+            'completeness',
+            'reconciliation',
+            'freshness',
+            'result',
+            'primaryReason',
+            'supportingReasons',
+            'summary',
+        ], ['evidenceBundleId']) ||
+        value.schemaVersion !== 1 ||
+        value.contractVersion !== FINANCIAL_EVIDENCE_ASSESSMENT_CONTRACT_VERSION_V1 ||
+        !isBoundedIdentity(value.policyVersion) ||
+        !isIsoInstant(value.evaluatedAt) ||
+        !isRecord(value.request) ||
+        !hasExactFields(value.request, ['provider', 'providerAccountRefs', 'scopeKind', 'scopeId', 'requestedEvidenceRoles']) ||
+        value.request.provider !== 'azure' ||
+        !Array.isArray(value.request.providerAccountRefs) ||
+        value.request.providerAccountRefs.length === 0 ||
+        value.request.providerAccountRefs.length > MAX_EVIDENCE_REFERENCES ||
+        !value.request.providerAccountRefs.every(isBoundedIdentity) ||
+        new Set(value.request.providerAccountRefs).size !== value.request.providerAccountRefs.length ||
+        typeof value.request.scopeKind !== 'string' ||
+        !SCOPE_KINDS.has(value.request.scopeKind) ||
+        !isBoundedIdentity(value.request.scopeId) ||
+        !Array.isArray(value.request.requestedEvidenceRoles) ||
+        value.request.requestedEvidenceRoles.length > EVIDENCE_ROLES.size ||
+        !value.request.requestedEvidenceRoles.every(role => typeof role === 'string' && EVIDENCE_ROLES.has(role)) ||
+        new Set(value.request.requestedEvidenceRoles).size !== value.request.requestedEvidenceRoles.length ||
+        !Array.isArray(value.roleAssessments) ||
+        value.roleAssessments.length > EVIDENCE_ROLES.size) {
+        return false;
+    }
+    const requestedRoles = new Set(value.request.requestedEvidenceRoles);
+    if (requestedRoles.size === 0 && !new Set(['subscription-aggregate', 'portfolio-currency-group']).has(value.request.scopeKind))
+        return false;
+    for (const item of value.roleAssessments) {
+        if (!isRecord(item) ||
+            !hasExactFields(item, ['role', 'support', 'requestState', 'productionState', 'matchState'], ['evidenceRefId']) ||
+            typeof item.role !== 'string' ||
+            !EVIDENCE_ROLES.has(item.role) ||
+            !new Set(['supported', 'unsupported', 'unknown']).has(String(item.support)) ||
+            !new Set(['requested', 'not-requested']).has(String(item.requestState)) ||
+            !new Set(['produced', 'not-produced']).has(String(item.productionState)) ||
+            !new Set(['matched', 'not-matched', 'not-applicable']).has(String(item.matchState)) ||
+            (item.evidenceRefId !== undefined && (typeof item.evidenceRefId !== 'string' || !SHA256_ID.test(item.evidenceRefId))) ||
+            (item.productionState === 'produced') !== (item.evidenceRefId !== undefined) ||
+            (item.matchState === 'matched' && item.productionState !== 'produced') ||
+            (item.requestState === 'requested') !== requestedRoles.has(item.role)) {
+            return false;
+        }
+    }
+    if (new Set(value.roleAssessments.map(item => item.role)).size !== value.roleAssessments.length)
+        return false;
+    if (!new Set(['complete', 'partial', 'unavailable', 'not-applicable']).has(String(value.completeness)) ||
+        !new Set(['reconciled', 'failed', 'not-applicable']).has(String(value.reconciliation)) ||
+        !new Set(['current', 'stale', 'unknown', 'not-applicable']).has(String(value.freshness)) ||
+        !new Set(['available', 'unavailable']).has(String(value.result)) ||
+        typeof value.primaryReason !== 'string' ||
+        !ASSESSMENT_REASONS.has(value.primaryReason) ||
+        !Array.isArray(value.supportingReasons) ||
+        value.supportingReasons.length > 16 ||
+        !value.supportingReasons.every(reason => typeof reason === 'string' && ASSESSMENT_REASONS.has(reason)) ||
+        new Set(value.supportingReasons).size !== value.supportingReasons.length ||
+        (value.evidenceBundleId !== undefined && (typeof value.evidenceBundleId !== 'string' || !SHA256_ID.test(value.evidenceBundleId))) ||
+        !isCountSummary(value.summary)) {
+        return false;
+    }
+    const producedCount = value.roleAssessments.filter(item => item.productionState === 'produced').length;
+    const matchedCount = value.roleAssessments.filter(item => item.matchState === 'matched').length;
+    const available = value.result === 'available';
+    return (value.summary.requestedRoleCount === requestedRoles.size &&
+        value.summary.producedRoleCount === producedCount &&
+        value.summary.matchedRoleCount === matchedCount &&
+        (!available ||
+            (value.completeness === 'complete' &&
+                value.reconciliation === 'reconciled' &&
+                value.freshness === 'current' &&
+                value.primaryReason === 'evidence-accepted' &&
+                value.evidenceBundleId !== undefined)));
+};
+export const canonicalizeFinancialEvidenceAssessmentIdentityV1 = (value) => {
+    if (!isAssessmentIdentity(value))
+        throw new TypeError('Invalid FinancialEvidenceAssessmentIdentityPreimageV1.');
+    return canonicalizeValidatedFinancialEvidenceAssessmentIdentityV1(value);
+};
+export const isFinancialEvidenceAssessmentV1 = (value) => {
+    if (!isRecord(value) || !Object.prototype.hasOwnProperty.call(value, 'assessmentId'))
+        return false;
+    const { assessmentId, ...identity } = value;
+    return (typeof assessmentId === 'string' &&
+        SHA256_ID.test(assessmentId) &&
+        isAssessmentIdentity(identity) &&
+        assessmentId === `sha256:${sha256Utf8(canonicalizeValidatedFinancialEvidenceAssessmentIdentityV1(identity))}`);
+};

package/dist/esm/azure/financialPolicy.js

@@ -0,0 +1,2 @@
+export const FINANCIAL_POLICY_DEFINITION_CONTRACT_VERSION_V1 = 'financial-policy-definition/v1';
+export const FINANCIAL_POLICY_EVALUATION_CONTRACT_VERSION_V1 = 'financial-policy-evaluation/v1';

package/dist/esm/azure/financialPolicyDelivery.js

@@ -0,0 +1,2 @@
+export const FINANCIAL_POLICY_READ_PROJECTION_CONTRACT_VERSION_V1 = 'financial-policy-read-projection/v1';
+export const FINANCIAL_POLICY_ACTION_ATTEMPT_CONTRACT_VERSION_V1 = 'financial-policy-action-attempt/v1';

package/dist/esm/azure/financialPolicyDeliveryValidation.js

@@ -0,0 +1,137 @@
+import { sha256Utf8 } from '../common/sha256.js';
+import { parseCanonicalDecimal } from '../common/exactDecimal.js';
+import { isCanonicalExactMoney } from './financialValidationPrimitives.js';
+import { FINANCIAL_POLICY_ACTION_ATTEMPT_CONTRACT_VERSION_V1, FINANCIAL_POLICY_READ_PROJECTION_CONTRACT_VERSION_V1, } from './financialPolicyDelivery.js';
+import { canonicalizeFinancialDataflowJsonV1, hasFinancialDataflowExactFieldsV1, isFinancialDataflowHashV1, isFinancialDataflowIdentityV1, isFinancialDataflowIsoInstantV1, isFinancialDataflowRecordV1, } from './financialDataflowValidation.js';
+import { createFinancialPolicyEvaluationActionAuditIdV1, createFinancialPolicyEvaluationReadProjectionIdV1, isFinancialPolicyDefinitionRevisionV1, isFinancialPolicyEvaluationV1, } from './financialPolicyValidation.js';
+const SIGNAL_KINDS = new Set(['budget-current-spend', 'budget-forecast', 'cost-anomaly']);
+const RESULTS = new Set(['matched', 'not-matched', 'partial', 'unavailable']);
+const ACTION_STATUSES = new Set(['succeeded', 'retryable-failure', 'terminal-failure']);
+const isNonNegativeDecimal = (value) => {
+    if (typeof value !== 'string' || !isCanonicalExactMoney({ amount: value, currencyCode: 'AUD' }))
+        return false;
+    try {
+        return parseCanonicalDecimal(value).coefficient >= 0n;
+    }
+    catch {
+        return false;
+    }
+};
+const isMatchedThresholds = (value) => Array.isArray(value) &&
+    value.length <= 64 &&
+    value.every(threshold => isFinancialDataflowRecordV1(threshold) &&
+        hasFinancialDataflowExactFieldsV1(threshold, ['thresholdKind', 'configuredValue']) &&
+        ['amount', 'percent', 'minimum-amount', 'minimum-delta', 'minimum-percent-change'].includes(String(threshold.thresholdKind)) &&
+        isNonNegativeDecimal(threshold.configuredValue)) &&
+    new Set(value.map(threshold => `${String(threshold.thresholdKind)}\u0000${String(threshold.configuredValue)}`)).size === value.length;
+export const isFinancialPolicyEvaluationReadProjectionV1 = (value) => isFinancialDataflowRecordV1(value) &&
+    hasFinancialDataflowExactFieldsV1(value, [
+        'schemaVersion',
+        'contractVersion',
+        'readProjectionId',
+        'evaluationId',
+        'companyId',
+        'definitionId',
+        'definitionRevision',
+        'coordinateId',
+        'currentSpendCompositionId',
+        'signalKind',
+        'evaluatedAt',
+        'result',
+        'reasonCode',
+        'matchedThresholds',
+    ], ['analyticsProjectionId']) &&
+    value.schemaVersion === 1 &&
+    value.contractVersion === FINANCIAL_POLICY_READ_PROJECTION_CONTRACT_VERSION_V1 &&
+    isFinancialDataflowHashV1(value.evaluationId) &&
+    value.readProjectionId === createFinancialPolicyEvaluationReadProjectionIdV1(value.evaluationId) &&
+    isFinancialDataflowIdentityV1(value.companyId) &&
+    isFinancialDataflowIdentityV1(value.definitionId) &&
+    isFinancialDataflowIdentityV1(value.definitionRevision) &&
+    isFinancialDataflowHashV1(value.coordinateId) &&
+    isFinancialDataflowHashV1(value.currentSpendCompositionId) &&
+    (value.analyticsProjectionId === undefined || isFinancialDataflowHashV1(value.analyticsProjectionId)) &&
+    typeof value.signalKind === 'string' &&
+    SIGNAL_KINDS.has(value.signalKind) &&
+    (value.signalKind === 'budget-current-spend' ? value.analyticsProjectionId === undefined : value.analyticsProjectionId !== undefined) &&
+    isFinancialDataflowIsoInstantV1(value.evaluatedAt) &&
+    typeof value.result === 'string' &&
+    RESULTS.has(value.result) &&
+    isFinancialDataflowIdentityV1(value.reasonCode) &&
+    isMatchedThresholds(value.matchedThresholds) &&
+    Array.isArray(value.matchedThresholds) &&
+    (value.result === 'matched' ? value.matchedThresholds.length > 0 : value.matchedThresholds.length === 0);
+export const isFinancialPolicyEvaluationReadProjectionCompatibleV1 = (projection, evaluation) => {
+    if (!isFinancialPolicyEvaluationReadProjectionV1(projection) || !isFinancialPolicyEvaluationV1(evaluation))
+        return false;
+    const expected = {
+        schemaVersion: 1,
+        contractVersion: FINANCIAL_POLICY_READ_PROJECTION_CONTRACT_VERSION_V1,
+        readProjectionId: evaluation.readProjectionId,
+        evaluationId: evaluation.evaluationId,
+        companyId: evaluation.companyId,
+        definitionId: evaluation.definitionId,
+        definitionRevision: evaluation.definitionRevision,
+        coordinateId: evaluation.coordinateId,
+        currentSpendCompositionId: evaluation.currentSpendCompositionId,
+        ...(evaluation.analyticsProjectionId === undefined ? {} : { analyticsProjectionId: evaluation.analyticsProjectionId }),
+        signalKind: evaluation.signalKind,
+        evaluatedAt: evaluation.evaluatedAt,
+        result: evaluation.result,
+        reasonCode: evaluation.reasonCode,
+        matchedThresholds: evaluation.matchedThresholds,
+    };
+    return canonicalizeFinancialDataflowJsonV1(projection) === canonicalizeFinancialDataflowJsonV1(expected);
+};
+const isActionAttemptIdentity = (value) => isFinancialDataflowRecordV1(value) &&
+    hasFinancialDataflowExactFieldsV1(value, [
+        'schemaVersion',
+        'contractVersion',
+        'actionAuditId',
+        'evaluationId',
+        'companyId',
+        'destinationRefId',
+        'attemptNumber',
+        'attemptedAt',
+        'status',
+        'reasonCode',
+        'executorVersion',
+    ]) &&
+    value.schemaVersion === 1 &&
+    value.contractVersion === FINANCIAL_POLICY_ACTION_ATTEMPT_CONTRACT_VERSION_V1 &&
+    isFinancialDataflowHashV1(value.evaluationId) &&
+    value.actionAuditId === createFinancialPolicyEvaluationActionAuditIdV1(value.evaluationId) &&
+    isFinancialDataflowIdentityV1(value.companyId) &&
+    isFinancialDataflowIdentityV1(value.destinationRefId) &&
+    Number.isSafeInteger(value.attemptNumber) &&
+    Number(value.attemptNumber) > 0 &&
+    isFinancialDataflowIsoInstantV1(value.attemptedAt) &&
+    typeof value.status === 'string' &&
+    ACTION_STATUSES.has(value.status) &&
+    isFinancialDataflowIdentityV1(value.reasonCode) &&
+    isFinancialDataflowIdentityV1(value.executorVersion);
+export const canonicalizeFinancialPolicyActionAttemptIdentityV1 = (value) => {
+    if (!isActionAttemptIdentity(value))
+        throw new TypeError('Invalid FinancialPolicyActionAttemptIdentityPreimageV1.');
+    return canonicalizeFinancialDataflowJsonV1(value);
+};
+export const createFinancialPolicyActionAttemptIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialPolicyActionAttemptIdentityV1(value))}`;
+export const isFinancialPolicyActionAttemptV1 = (value) => {
+    if (!isFinancialDataflowRecordV1(value) || !Object.prototype.hasOwnProperty.call(value, 'actionAttemptId'))
+        return false;
+    const { actionAttemptId, ...identity } = value;
+    return (isFinancialDataflowHashV1(actionAttemptId) &&
+        isActionAttemptIdentity(identity) &&
+        actionAttemptId === createFinancialPolicyActionAttemptIdV1(identity));
+};
+export const isFinancialPolicyActionAttemptCompatibleV1 = (attempt, evaluation, definition) => isFinancialPolicyActionAttemptV1(attempt) &&
+    isFinancialPolicyEvaluationV1(evaluation) &&
+    isFinancialPolicyDefinitionRevisionV1(definition) &&
+    definition.effectiveState === 'enabled' &&
+    evaluation.result === 'matched' &&
+    attempt.evaluationId === evaluation.evaluationId &&
+    attempt.actionAuditId === evaluation.actionAuditId &&
+    attempt.companyId === evaluation.companyId &&
+    Date.parse(attempt.attemptedAt) >= Date.parse(evaluation.evaluatedAt) &&
+    evaluation.policyDefinitionRevisionId === definition.policyDefinitionRevisionId &&
+    definition.destinationRefIds.includes(attempt.destinationRefId);