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

package/dist/esm/azure/financialDisplayRollup.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/azure/financialDisplayRollupValidation.js

@@ -0,0 +1,75 @@
+import { sha256Utf8 } from '../common/sha256.js';
+const SHA256_ID = /^sha256:[0-9a-f]{64}$/;
+const DISPLAY_LABEL_SOURCES = new Set(['meter-name', 'product-name', 'meter-subcategory', 'meter-category', 'service-name', 'charge-classification']);
+const ROLLUP_LABEL_SOURCES = new Set(['service-name', 'meter-category', 'charge-classification']);
+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 isHash = (value) => typeof value === 'string' && SHA256_ID.test(value);
+const isBoundedText = (value, maxLength = 512) => typeof value === 'string' && value.length > 0 && value.length <= maxLength && value.trim() === value;
+const isHashArray = (value) => Array.isArray(value) && value.length > 0 && value.length <= 256 && value.every(isHash) && new Set(value).size === value.length;
+const labelSourceValue = (value) => {
+    switch (value.displayLabelSource) {
+        case 'meter-name':
+            return value.meterName;
+        case 'product-name':
+            return value.productName;
+        case 'meter-subcategory':
+            return value.meterSubCategory;
+        case 'meter-category':
+            return value.meterCategory;
+        case 'service-name':
+            return value.serviceName;
+        case 'charge-classification':
+            return undefined;
+    }
+};
+export const isFinancialAuthorityComponentDescriptorV1 = (value) => {
+    if (!isRecord(value) ||
+        !hasExactFields(value, ['baselineId', 'componentId', 'displayLabel', 'displayLabelSource', 'evidenceRefIds'], ['serviceName', 'meterCategory', 'meterSubCategory', 'meterName', 'productName', 'unitOfMeasure']) ||
+        !isHash(value.baselineId) ||
+        !isHash(value.componentId) ||
+        !isBoundedText(value.displayLabel) ||
+        typeof value.displayLabelSource !== 'string' ||
+        !DISPLAY_LABEL_SOURCES.has(value.displayLabelSource) ||
+        !isHashArray(value.evidenceRefIds) ||
+        ['serviceName', 'meterCategory', 'meterSubCategory', 'meterName', 'productName', 'unitOfMeasure'].some(field => value[field] !== undefined && !isBoundedText(value[field])))
+        return false;
+    const descriptor = value;
+    const sourceValue = labelSourceValue(descriptor);
+    return descriptor.displayLabelSource === 'charge-classification' || sourceValue === descriptor.displayLabel;
+};
+const canonicalRollupPreimage = (value) => ({
+    displayScopeId: value.displayScopeId,
+    purpose: value.purpose,
+    additivity: value.additivity,
+    displayLabel: value.displayLabel,
+    displayLabelSource: value.displayLabelSource,
+    members: [...value.members].sort((left, right) => `${left.baselineId}\u0000${left.componentId}`.localeCompare(`${right.baselineId}\u0000${right.componentId}`)),
+});
+export const createFinancialDisplayRollupIdV1 = (value) => `sha256:${sha256Utf8(JSON.stringify(canonicalRollupPreimage(value)))}`;
+export const isFinancialDisplayRollupV1 = (value) => {
+    if (!isRecord(value) ||
+        !hasExactFields(value, ['displayRollupId', 'displayScopeId', 'purpose', 'additivity', 'displayLabel', 'displayLabelSource', 'members']) ||
+        !isHash(value.displayRollupId) ||
+        !isBoundedText(value.displayScopeId, 2048) ||
+        value.purpose !== 'cost-composition' ||
+        value.additivity !== 'non-additive' ||
+        !isBoundedText(value.displayLabel) ||
+        typeof value.displayLabelSource !== 'string' ||
+        !ROLLUP_LABEL_SOURCES.has(value.displayLabelSource) ||
+        !Array.isArray(value.members) ||
+        value.members.length === 0 ||
+        value.members.length > 20000 ||
+        !value.members.every(member => isRecord(member) && hasExactFields(member, ['baselineId', 'componentId']) && isHash(member.baselineId) && isHash(member.componentId)))
+        return false;
+    const rollup = value;
+    const membershipKeys = rollup.members.map(member => `${member.baselineId}\u0000${member.componentId}`);
+    if (new Set(membershipKeys).size !== membershipKeys.length)
+        return false;
+    const { displayRollupId: _displayRollupId, ...identity } = rollup;
+    return rollup.displayRollupId === createFinancialDisplayRollupIdV1(identity);
+};

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,160 @@
+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',
+    'commercial-arrangement',
+    'provider-access-observation',
+    'configuration-timeline',
+    'provider-price-schedule',
+    'pricing-function',
+    'charge-inclusion-policy',
+    'settlement-revision',
+    '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/financialEvidenceCoverage.js

@@ -0,0 +1,106 @@
+export const FINANCIAL_EVIDENCE_COVERAGE_CONTRACT_VERSION_V1 = 'financial-evidence-coverage/v1';
+export const FINANCIAL_EVIDENCE_COVERAGE_REASONS_V1 = [
+    'coverage-complete',
+    'capability-passport-missing',
+    'capability-passport-invalid',
+    'capability-passport-ownership-mismatch',
+    'capability-passport-read-failed',
+    'billing-capability-partial',
+    'billing-capability-stale',
+    'billing-capability-missing',
+    'billing-capability-unavailable',
+    'billing-capability-unknown',
+    'billing-dependency-partial',
+    'billing-dependency-stale',
+    'billing-dependency-missing',
+    'billing-dependency-unavailable',
+    'billing-dependency-unverified',
+    'billing-dependency-wrong-generation',
+    'subscription-coverage-missing',
+    'subscription-coverage-invalid',
+    'filtered-scope-coverage-unproven',
+];
+const STATES = new Set(['complete', 'partial', 'stale', 'missing', 'unavailable', 'unknown']);
+const STATE_PRIORITY = {
+    complete: 0,
+    partial: 1,
+    stale: 2,
+    unknown: 3,
+    missing: 4,
+    unavailable: 5,
+};
+const REASONS = new Set(FINANCIAL_EVIDENCE_COVERAGE_REASONS_V1);
+const ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const hasExactFields = (value, required, optional = []) => {
+    const allowed = new Set([...required, ...optional]);
+    return required.every(field => Object.prototype.hasOwnProperty.call(value, field)) && Object.keys(value).every(field => allowed.has(field));
+};
+const isNonEmptyString = (value) => typeof value === 'string' && value.trim() === value && value.length > 0;
+const isCanonicalTimestamp = (value) => typeof value === 'string' &&
+    ISO_TIMESTAMP_PATTERN.test(value) &&
+    Number.isFinite(Date.parse(value)) &&
+    new Date(Date.parse(value)).toISOString() === value;
+const isReasonList = (value) => Array.isArray(value) && value.length > 0 && new Set(value).size === value.length && value.every(reason => typeof reason === 'string' && REASONS.has(reason));
+const isSource = (value) => {
+    if (!isRecord(value) || !hasExactFields(value, ['state', 'reasons'], ['generationId', 'completeThrough']))
+        return false;
+    if (typeof value.state !== 'string' || !STATES.has(value.state) || !isReasonList(value.reasons))
+        return false;
+    if (value.state === 'complete' ? value.reasons.length !== 1 || value.reasons[0] !== 'coverage-complete' : value.reasons.includes('coverage-complete')) {
+        return false;
+    }
+    if (value.generationId !== undefined && !isNonEmptyString(value.generationId))
+        return false;
+    return value.completeThrough === undefined || isCanonicalTimestamp(value.completeThrough);
+};
+/** Exact dependency-free validator for the API/UI coverage boundary. */
+export const isFinancialEvidenceCoverageProjectionV1 = (value) => {
+    if (!isRecord(value) ||
+        !hasExactFields(value, [
+            'contractVersion',
+            'provider',
+            'subscriptionId',
+            'publicationId',
+            'artifactGeneration',
+            'scope',
+            'state',
+            'reasons',
+            'sources',
+        ]) ||
+        value.contractVersion !== FINANCIAL_EVIDENCE_COVERAGE_CONTRACT_VERSION_V1 ||
+        value.provider !== 'azure' ||
+        !isNonEmptyString(value.subscriptionId) ||
+        !isNonEmptyString(value.publicationId) ||
+        typeof value.state !== 'string' ||
+        !STATES.has(value.state) ||
+        !isReasonList(value.reasons)) {
+        return false;
+    }
+    if (!isRecord(value.artifactGeneration) ||
+        !hasExactFields(value.artifactGeneration, ['runId', 'generatedAt']) ||
+        !isNonEmptyString(value.artifactGeneration.runId) ||
+        !isCanonicalTimestamp(value.artifactGeneration.generatedAt)) {
+        return false;
+    }
+    if (!isRecord(value.scope) ||
+        !hasExactFields(value.scope, ['kind', 'subscriptionId']) ||
+        value.scope.kind !== 'subscription' ||
+        value.scope.subscriptionId !== value.subscriptionId) {
+        return false;
+    }
+    if (!isRecord(value.sources) ||
+        !hasExactFields(value.sources, ['capabilityPassport', 'billingDependency']) ||
+        !isSource(value.sources.capabilityPassport) ||
+        !isSource(value.sources.billingDependency)) {
+        return false;
+    }
+    const sources = [value.sources.capabilityPassport, value.sources.billingDependency];
+    const expectedState = sources.reduce((current, candidate) => (STATE_PRIORITY[candidate.state] > STATE_PRIORITY[current] ? candidate.state : current), 'complete');
+    if (value.state !== expectedState)
+        return false;
+    const expectedReasons = new Set(expectedState === 'complete'
+        ? ['coverage-complete']
+        : sources.flatMap(candidate => candidate.reasons).filter(reason => reason !== 'coverage-complete'));
+    return expectedReasons.size === value.reasons.length && value.reasons.every(reason => expectedReasons.has(reason));
+};

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,6 @@
+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';
+export const FINANCIAL_POLICY_DEFINITION_COMMAND_CONTRACT_VERSION_V1 = 'financial-policy-definition-command/v1';
+export const FINANCIAL_POLICY_READ_CURRENT_POINTER_CONTRACT_VERSION_V1 = 'financial-policy-read-current-pointer/v1';
+export const FINANCIAL_POLICY_ACTION_COMPLETION_CONTRACT_VERSION_V1 = 'financial-policy-action-completion/v1';
+export const FINANCIAL_POLICY_READ_MANIFEST_CONTRACT_VERSION_V1 = 'financial-policy-read-manifest/v1';