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

package/dist/esm/azure/financialAuthorityProjectionKernel.js

@@ -1,263 +0,0 @@
-import { FINANCIAL_AUTHORITY_RESOURCE_PROJECTION_CONTRACT_VERSION_V1, } from './financialAuthorityView.js';
-import { FINANCIAL_SAVINGS_RESOURCE_PROJECTION_CONTRACT_VERSION_V1, } from './financialSavingsAuthority.js';
-import { AZURE_BILLED_ALL_CHARGES_POLICY_V1, resolveFinancialChargeInclusionPolicyV1, } from './financialChargeComposition.js';
-import { classifyFinancialSavingsAllocationForPolicyV1 } from './financialSavingsChargePolicyKernel.js';
-const normalize = (value) => value.trim().toLowerCase().replace(/\/+$/, '');
-/** Derives one compact, non-additive resource view from a validated canonical authority. */
-export const projectFinancialAuthorityResourceV1 = (authority, resourceType, scopeId) => {
-    const normalizedType = normalize(resourceType);
-    const normalizedScopeId = normalize(scopeId);
-    const coverage = authority.scopeCoverage.find(entry => normalize(entry.resourceType) === normalizedType && entry.scopeIds.some(candidate => normalize(candidate) === normalizedScopeId));
-    if (!coverage)
-        return undefined;
-    const coordinates = authority.coordinates.map(coordinate => {
-        const owners = coordinate.ownerBaselines.filter(baseline => normalize(baseline.scopeId) === normalizedScopeId);
-        const ownerBaseline = owners[0];
-        if (owners.length !== 1 || !ownerBaseline)
-            throw new TypeError('Financial authority resource owner is missing or ambiguous.');
-        const chargeComposition = ownerBaseline.status === 'available' && ownerBaseline.baselineKind === 'owner'
-            ? coordinate.chargeCompositions.find(composition => composition.baselineId === ownerBaseline.baselineId)
-            : undefined;
-        if (ownerBaseline.status === 'available' && ownerBaseline.baselineKind === 'owner' && !chargeComposition) {
-            throw new TypeError('Financial authority resource charge composition is missing.');
-        }
-        const displayRollups = (coordinate.displayRollups ?? []).filter(rollup => normalize(rollup.displayScopeId) === normalizedScopeId);
-        const displayMemberBaselineIds = new Set(displayRollups.flatMap(rollup => rollup.members.map(member => member.baselineId)).filter(baselineId => baselineId !== ownerBaseline.baselineId));
-        const displayMemberBaselines = coordinate.ownerBaselines.filter(baseline => baseline.status === 'available' &&
-            baseline.baselineKind === 'owner' &&
-            displayMemberBaselineIds.has(baseline.baselineId));
-        if (displayMemberBaselines.length !== displayMemberBaselineIds.size) {
-            throw new TypeError('Financial authority resource display member baseline is missing.');
-        }
-        const displayMemberChargeCompositions = (coordinate.chargeCompositions ?? []).filter(composition => displayMemberBaselineIds.has(composition.baselineId));
-        if (displayMemberBaselines.some(baseline => baseline.status === 'available' &&
-            baseline.baselineKind === 'owner' &&
-            !displayMemberChargeCompositions.some(composition => composition.baselineId === baseline.baselineId))) {
-            throw new TypeError('Financial authority resource display member charge composition is missing.');
-        }
-        const displayMemberships = new Set(displayRollups.flatMap(rollup => rollup.members.map(member => `${member.baselineId}\u0000${member.componentId}`)));
-        return {
-            coordinateId: coordinate.coordinateId,
-            periodRole: coordinate.periodRole,
-            period: coordinate.period,
-            costBasis: coordinate.costBasis,
-            estimateLens: coordinate.estimateLens,
-            ...(coordinate.requestedCurrencyCode === undefined ? {} : { requestedCurrencyCode: coordinate.requestedCurrencyCode }),
-            ownerBaseline,
-            ...(displayMemberBaselines.length === 0 ? {} : { displayMemberBaselines }),
-            ...(chargeComposition === undefined ? {} : { chargeComposition }),
-            ...(displayMemberChargeCompositions.length === 0 ? {} : { displayMemberChargeCompositions }),
-            componentDescriptors: (coordinate.componentDescriptors ?? []).filter(descriptor => displayMemberships.has(`${descriptor.baselineId}\u0000${descriptor.componentId}`)),
-            displayRollups,
-            projections: coordinate.projections.filter(projection => normalize(projection.scopeId) === normalizedScopeId),
-        };
-    });
-    const firstCoordinate = coordinates[0];
-    if (!firstCoordinate)
-        throw new TypeError('Financial authority resource projection has no coordinates.');
-    const assessmentIds = new Set();
-    const bundleIds = new Set();
-    coordinates.forEach(coordinate => {
-        assessmentIds.add(coordinate.ownerBaseline.assessmentId);
-        if (coordinate.ownerBaseline.status === 'available' && coordinate.ownerBaseline.baselineKind === 'owner') {
-            bundleIds.add(coordinate.ownerBaseline.evidenceBundleId);
-        }
-        for (const baseline of coordinate.displayMemberBaselines ?? []) {
-            assessmentIds.add(baseline.assessmentId);
-            if (baseline.status === 'available' && baseline.baselineKind === 'owner')
-                bundleIds.add(baseline.evidenceBundleId);
-        }
-        coordinate.projections.forEach(projection => {
-            if (projection.targetAssessmentId)
-                assessmentIds.add(projection.targetAssessmentId);
-            if (projection.targetEvidenceBundleId)
-                bundleIds.add(projection.targetEvidenceBundleId);
-        });
-    });
-    const evidenceAssessments = authority.evidenceAssessments.filter(assessment => assessmentIds.has(assessment.assessmentId));
-    evidenceAssessments.forEach(assessment => {
-        if (assessment.evidenceBundleId)
-            bundleIds.add(assessment.evidenceBundleId);
-    });
-    return {
-        contractVersion: FINANCIAL_AUTHORITY_RESOURCE_PROJECTION_CONTRACT_VERSION_V1,
-        authorityId: authority.authorityId,
-        provider: authority.provider,
-        providerAccountRefs: authority.providerAccountRefs,
-        artifactGeneration: authority.artifactGeneration,
-        billingGenerationId: authority.billingGenerationId,
-        resourceType: coverage.resourceType,
-        financialRole: coverage.financialRole,
-        scopeId: normalizedScopeId,
-        evidenceBundles: authority.evidenceBundles.filter(bundle => bundleIds.has(bundle.bundleId)),
-        evidenceAssessments,
-        coordinates: [firstCoordinate, ...coordinates.slice(1)],
-    };
-};
-/** Derives the matching compact savings view for one canonical resource owner. */
-export const projectFinancialSavingsResourceV1 = (savingsAuthority, financialProjection, financialAuthority, chargeInclusionPolicyRef = AZURE_BILLED_ALL_CHARGES_POLICY_V1.policyRef) => {
-    if (savingsAuthority.financialAuthorityId !== financialProjection.authorityId ||
-        savingsAuthority.artifactGeneration.runId !== financialProjection.artifactGeneration.runId ||
-        savingsAuthority.artifactGeneration.generatedAt !== financialProjection.artifactGeneration.generatedAt) {
-        throw new TypeError('Financial savings authority is not bound to the resource Financial Authority projection.');
-    }
-    if (!resolveFinancialChargeInclusionPolicyV1(chargeInclusionPolicyRef)) {
-        throw new TypeError('Financial savings resource charge-inclusion policy is not registered.');
-    }
-    if (financialAuthority !== undefined &&
-        (financialAuthority.authorityId !== financialProjection.authorityId ||
-            financialAuthority.artifactGeneration.runId !== financialProjection.artifactGeneration.runId ||
-            financialAuthority.artifactGeneration.generatedAt !== financialProjection.artifactGeneration.generatedAt)) {
-        throw new TypeError('Full Financial Authority is not bound to the resource projection.');
-    }
-    const normalizedScopeId = normalize(financialProjection.scopeId);
-    const financialCoordinateIds = new Set(financialProjection.coordinates.map(coordinate => coordinate.coordinateId));
-    const savingsByCoordinateId = new Map(savingsAuthority.coordinates.map(coordinate => [coordinate.coordinateId, coordinate]));
-    if (financialCoordinateIds.size !== financialProjection.coordinates.length ||
-        savingsAuthority.coordinates.length !== financialProjection.coordinates.length ||
-        savingsAuthority.coordinates.some(coordinate => !financialCoordinateIds.has(coordinate.coordinateId))) {
-        throw new TypeError('Financial savings coordinates do not match the resource Financial Authority projection.');
-    }
-    const coordinates = financialProjection.coordinates.map(financialCoordinate => {
-        const coordinate = savingsByCoordinateId.get(financialCoordinate.coordinateId);
-        if (!coordinate)
-            throw new TypeError('Financial savings coordinate is missing.');
-        if (coordinate.status === 'unavailable')
-            return { ...coordinate, chargeInclusionPolicyRef };
-        const displayOwnerScopeIds = new Set((financialCoordinate.displayMemberBaselines ?? []).map(baseline => normalize(baseline.scopeId)));
-        displayOwnerScopeIds.delete(normalizedScopeId);
-        const selectedOwnerScopeIds = new Set([normalizedScopeId, ...displayOwnerScopeIds]);
-        const resourceAllocations = coordinate.allocations.filter(allocation => selectedOwnerScopeIds.has(normalize(allocation.ownerScopeId)));
-        const sourceResourceContributions = coordinate.resourceContributions.filter(contribution => selectedOwnerScopeIds.has(normalize(contribution.ownerScopeId)));
-        const sourceResourceContributionByOwner = new Map();
-        for (const contribution of sourceResourceContributions) {
-            const ownerScopeId = normalize(contribution.ownerScopeId);
-            if (sourceResourceContributionByOwner.has(ownerScopeId)) {
-                throw new TypeError('Financial savings resource contribution is ambiguous.');
-            }
-            sourceResourceContributionByOwner.set(ownerScopeId, contribution);
-        }
-        for (const ownerScopeId of selectedOwnerScopeIds) {
-            const sourceRecommendationSavings = coordinate.recommendationContributions
-                .filter(contribution => normalize(contribution.ownerScopeId) === ownerScopeId)
-                .reduce((total, contribution) => {
-                const next = total + contribution.savingsMinorUnits;
-                if (!Number.isSafeInteger(next)) {
-                    throw new TypeError('Financial savings recommendation contribution overflows safe minor units.');
-                }
-                return next;
-            }, 0);
-            if ((sourceResourceContributionByOwner.get(ownerScopeId)?.savingsMinorUnits ?? 0) !== sourceRecommendationSavings) {
-                throw new TypeError('Financial savings recommendation contributions do not reconcile to the resource contribution.');
-            }
-        }
-        const policyUnavailableScenarioIds = new Set();
-        const chargeCompositionByBaselineId = new Map([
-            ...(financialCoordinate.chargeComposition ? [financialCoordinate.chargeComposition] : []),
-            ...(financialCoordinate.displayMemberChargeCompositions ?? []),
-        ].map(composition => [composition.baselineId, composition]));
-        const selectedAllocations = resourceAllocations.filter(allocation => {
-            if (chargeInclusionPolicyRef.policyId === AZURE_BILLED_ALL_CHARGES_POLICY_V1.policyRef.policyId &&
-                chargeInclusionPolicyRef.policyDigest === AZURE_BILLED_ALL_CHARGES_POLICY_V1.policyRef.policyDigest)
-                return true;
-            const disposition = classifyFinancialSavingsAllocationForPolicyV1(chargeCompositionByBaselineId, allocation, chargeInclusionPolicyRef);
-            if (disposition === 'unavailable')
-                policyUnavailableScenarioIds.add(allocation.scenarioId);
-            return disposition === 'included';
-        });
-        const allocationsByRecommendation = new Map();
-        for (const allocation of selectedAllocations) {
-            const key = `${normalize(allocation.ownerScopeId)}\u0000${allocation.recommendationId}`;
-            const current = allocationsByRecommendation.get(key) ?? [];
-            current.push(allocation);
-            allocationsByRecommendation.set(key, current);
-        }
-        const allRecommendationContributions = [...allocationsByRecommendation.entries()]
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([, allocations]) => {
-            const firstAllocation = allocations[0];
-            if (!firstAllocation)
-                throw new TypeError('Financial savings recommendation contribution has no allocation.');
-            const savingsMinorUnits = allocations.reduce((total, allocation) => {
-                const next = total + allocation.savingsMinorUnits;
-                if (!Number.isSafeInteger(next)) {
-                    throw new TypeError('Financial savings recommendation contribution overflows safe minor units.');
-                }
-                return next;
-            }, 0);
-            return {
-                ownerScopeId: normalize(firstAllocation.ownerScopeId),
-                recommendationId: firstAllocation.recommendationId,
-                allocationIds: allocations.map(allocation => allocation.allocationId),
-                savingsMinorUnits,
-            };
-        });
-        const recommendationContributions = allRecommendationContributions.filter(contribution => normalize(contribution.ownerScopeId) === normalizedScopeId);
-        const displayMemberRecommendationContributions = allRecommendationContributions.filter(contribution => displayOwnerScopeIds.has(normalize(contribution.ownerScopeId)));
-        const buildResourceContribution = (ownerScopeId) => {
-            const allocations = selectedAllocations.filter(allocation => normalize(allocation.ownerScopeId) === ownerScopeId);
-            if (allocations.length === 0)
-                return undefined;
-            const savingsMinorUnits = allocations.reduce((total, allocation) => {
-                const next = total + allocation.savingsMinorUnits;
-                if (!Number.isSafeInteger(next))
-                    throw new TypeError('Financial savings resource contribution overflows safe minor units.');
-                return next;
-            }, 0);
-            return {
-                ownerScopeId,
-                allocationIds: allocations.map(allocation => allocation.allocationId),
-                savingsMinorUnits,
-            };
-        };
-        const resourceContribution = buildResourceContribution(normalizedScopeId);
-        const displayMemberResourceContributions = [...displayOwnerScopeIds]
-            .sort()
-            .map(buildResourceContribution)
-            .filter((contribution) => contribution !== undefined);
-        const unavailableActivationIds = new Set(coordinate.status === 'partial'
-            ? coordinate.activations.filter(activation => activation.result === 'unavailable').map(activation => activation.scenarioId)
-            : []);
-        const authorityCoordinate = financialAuthority?.coordinates.find(candidate => candidate.coordinateId === financialCoordinate.coordinateId);
-        if (financialAuthority !== undefined && !authorityCoordinate) {
-            throw new TypeError('Full Financial Authority coordinate is missing for the resource projection.');
-        }
-        const unavailableScenarioIds = [...new Set([...unavailableActivationIds, ...policyUnavailableScenarioIds])]
-            .filter(scenarioId => {
-            if (!authorityCoordinate) {
-                // Without the full authority there is no proof that an absent target
-                // projection belongs elsewhere. Preserve the gap on this resource.
-                return true;
-            }
-            const scenarioProjections = authorityCoordinate.projections.filter(projection => projection.scenarioId === scenarioId);
-            return scenarioProjections.length === 0 || scenarioProjections.some(projection => selectedOwnerScopeIds.has(normalize(projection.scopeId)));
-        })
-            .sort();
-        const composed = {
-            coordinateId: coordinate.coordinateId,
-            chargeInclusionPolicyRef,
-            currentAggregateBaselineId: coordinate.currentAggregateBaselineId,
-            accountingCurrencyCode: coordinate.accountingCurrencyCode,
-            minorUnitScale: coordinate.minorUnitScale,
-            roundingMode: coordinate.roundingMode,
-            ...(resourceContribution === undefined ? {} : { resourceContribution }),
-            recommendationContributions,
-            ...(displayMemberResourceContributions.length === 0 ? {} : { displayMemberResourceContributions }),
-            ...(displayMemberRecommendationContributions.length === 0 ? {} : { displayMemberRecommendationContributions }),
-        };
-        return unavailableScenarioIds.length > 0
-            ? { ...composed, status: 'partial', unavailableScenarioIds: unavailableScenarioIds }
-            : { ...composed, status: 'available' };
-    });
-    const firstCoordinate = coordinates[0];
-    if (!firstCoordinate)
-        throw new TypeError('Financial savings resource projection has no coordinates.');
-    return {
-        contractVersion: FINANCIAL_SAVINGS_RESOURCE_PROJECTION_CONTRACT_VERSION_V1,
-        savingsAuthorityId: savingsAuthority.savingsAuthorityId,
-        financialAuthorityId: savingsAuthority.financialAuthorityId,
-        artifactGeneration: savingsAuthority.artifactGeneration,
-        scopeId: normalizedScopeId,
-        coordinates: [firstCoordinate, ...coordinates.slice(1)],
-    };
-};

package/dist/esm/azure/financialChargeComposition.js

@@ -1,36 +0,0 @@
-import { sha256Utf8 } from '../common/sha256.js';
-export const FINANCIAL_CHARGE_COMPOSITION_SCHEMA_VERSION_V1 = 1;
-export const FINANCIAL_CHARGE_COMPOSITION_CONTRACT_VERSION_V1 = 'financial-charge-composition/v1';
-export const FINANCIAL_CHARGE_INCLUSION_POLICY_CONTRACT_VERSION_V1 = 'financial-charge-inclusion-policy/v1';
-const createRegisteredPolicy = (definition) => {
-    const { policyId, ...policy } = definition;
-    const registered = {
-        ...policy,
-        includeSources: Object.freeze([...policy.includeSources]),
-        excludeSources: Object.freeze([...policy.excludeSources]),
-        withholdSources: Object.freeze([...policy.withholdSources]),
-        policyRef: Object.freeze({ policyId, policyDigest: `sha256:${sha256Utf8(JSON.stringify(definition))}` }),
-    };
-    return Object.freeze(registered);
-};
-export const AZURE_BILLED_ALL_CHARGES_POLICY_V1 = createRegisteredPolicy({
-    schemaVersion: 1,
-    contractVersion: FINANCIAL_CHARGE_INCLUSION_POLICY_CONTRACT_VERSION_V1,
-    policyId: 'azure-billed-all-charges/v1',
-    includeSources: ['azure-native', 'marketplace', 'unknown'],
-    excludeSources: [],
-    withholdSources: [],
-});
-export const AZURE_CLOUD_SERVICES_EXCLUDING_MARKETPLACE_POLICY_V1 = createRegisteredPolicy({
-    schemaVersion: 1,
-    contractVersion: FINANCIAL_CHARGE_INCLUSION_POLICY_CONTRACT_VERSION_V1,
-    policyId: 'azure-cloud-services-excluding-marketplace/v1',
-    includeSources: ['azure-native'],
-    excludeSources: ['marketplace'],
-    withholdSources: ['unknown'],
-});
-export const FINANCIAL_CHARGE_INCLUSION_POLICIES_V1 = Object.freeze([
-    AZURE_BILLED_ALL_CHARGES_POLICY_V1,
-    AZURE_CLOUD_SERVICES_EXCLUDING_MARKETPLACE_POLICY_V1,
-]);
-export const resolveFinancialChargeInclusionPolicyV1 = (policyRef) => policyRef !== null && typeof policyRef === 'object' && FINANCIAL_CHARGE_INCLUSION_POLICIES_V1.find(policy => policy.policyRef.policyId === policyRef.policyId && policy.policyRef.policyDigest === policyRef.policyDigest) || undefined;

package/dist/esm/azure/financialChargeCompositionKernel.js

@@ -1,48 +0,0 @@
-import { formatExactDecimalValue, sumCanonicalDecimals } from '../common/exactDecimal.js';
-import { FINANCIAL_CHARGE_COMPOSITION_CONTRACT_VERSION_V1, FINANCIAL_CHARGE_COMPOSITION_SCHEMA_VERSION_V1, } from './financialChargeComposition.js';
-import { createFinancialChargeCompositionIdV1 } from './financialChargeCompositionValidation.js';
-const bucketKey = (component) => `${component.chargeSource}\u0000${component.chargeRecurrence}\u0000${component.chargeClassification}`;
-export const createFinancialChargeCompositionV1 = (request) => {
-    if (!Array.isArray(request.components) || request.components.length === 0 || request.components.length > 20000) {
-        throw new TypeError('Financial charge composition requires a bounded non-empty component collection.');
-    }
-    if (new Set(request.components.map(component => component.componentId)).size !== request.components.length) {
-        throw new TypeError('Financial charge composition cannot classify one component more than once.');
-    }
-    const groups = new Map();
-    for (const component of request.components) {
-        const key = bucketKey(component);
-        const group = groups.get(key);
-        if (group)
-            group.push(component);
-        else
-            groups.set(key, [component]);
-    }
-    const buckets = [...groups.values()]
-        .map(group => ({
-        chargeSource: group[0].chargeSource,
-        chargeRecurrence: group[0].chargeRecurrence,
-        chargeClassification: group[0].chargeClassification,
-        amount: formatExactDecimalValue(sumCanonicalDecimals(group.map(component => component.amount))),
-        componentIds: [...new Set(group.map(component => component.componentId))].sort(),
-        evidenceRefIds: [...new Set(group.flatMap(component => component.evidenceRefIds))].sort(),
-    }))
-        .sort((left, right) => `${left.chargeSource}\u0000${left.chargeRecurrence}\u0000${left.chargeClassification}`.localeCompare(`${right.chargeSource}\u0000${right.chargeRecurrence}\u0000${right.chargeClassification}`));
-    const bucketTotal = formatExactDecimalValue(sumCanonicalDecimals(buckets.map(bucket => bucket.amount)));
-    if (bucketTotal !== request.sourceTotal)
-        throw new TypeError('Financial charge composition does not reconcile to its source total.');
-    const identity = {
-        schemaVersion: FINANCIAL_CHARGE_COMPOSITION_SCHEMA_VERSION_V1,
-        contractVersion: FINANCIAL_CHARGE_COMPOSITION_CONTRACT_VERSION_V1,
-        baselineId: request.baselineId,
-        ownerScopeId: request.ownerScopeId,
-        period: request.period,
-        costBasis: request.costBasis,
-        estimateLens: request.estimateLens,
-        accountingCurrencyCode: request.accountingCurrencyCode,
-        buckets,
-        reconciliation: { status: 'reconciled', bucketTotal, sourceTotal: request.sourceTotal, difference: '0' },
-        algorithmVersion: request.algorithmVersion,
-    };
-    return { ...identity, chargeCompositionId: createFinancialChargeCompositionIdV1(identity) };
-};

package/dist/esm/azure/financialChargeCompositionValidation.js

@@ -1,155 +0,0 @@
-import { formatExactDecimalValue, sumCanonicalDecimals } from '../common/exactDecimal.js';
-import { sha256Utf8 } from '../common/sha256.js';
-import { FINANCIAL_CHARGE_COMPOSITION_CONTRACT_VERSION_V1, FINANCIAL_CHARGE_COMPOSITION_SCHEMA_VERSION_V1, resolveFinancialChargeInclusionPolicyV1, } from './financialChargeComposition.js';
-import { canonicalizeFinancialDataflowJsonV1, hasFinancialDataflowExactFieldsV1, isFinancialDataflowCurrencyV1, isFinancialDataflowHashV1, isFinancialDataflowIdentityV1, isFinancialDataflowRecordV1, isFinancialDataflowValueWithinLimitsV1, } from './financialDataflowValidation.js';
-import { isFinancialBaselinePeriodV2 } from './financialScopeBaselineValidation.js';
-import { isCanonicalExactMoney } from './financialValidationPrimitives.js';
-const SOURCES = new Set(['azure-native', 'marketplace', 'unknown']);
-const RECURRENCES = new Set(['one-time', 'recurring', 'usage-based', 'unknown']);
-const CLASSIFICATIONS = new Set(['usage', 'purchase', 'adjustment', 'tax', 'credit', 'refund', 'residual']);
-const COST_BASES = new Set(['billed', 'amortized']);
-const ESTIMATE_LENSES = new Set(['actual-only', 'actual-plus-estimated', 'estimates-only']);
-const isSortedUniqueHashes = (value) => Array.isArray(value) && value.length > 0 && value.length <= 20000 && value.every(isFinancialDataflowHashV1) &&
-    value.every((entry, index) => index === 0 || value[index - 1] < entry);
-const isBucket = (value) => isFinancialDataflowRecordV1(value) &&
-    hasFinancialDataflowExactFieldsV1(value, [
-        'chargeSource',
-        'chargeRecurrence',
-        'chargeClassification',
-        'amount',
-        'componentIds',
-        'evidenceRefIds',
-    ]) &&
-    SOURCES.has(value.chargeSource) &&
-    RECURRENCES.has(value.chargeRecurrence) &&
-    CLASSIFICATIONS.has(value.chargeClassification) &&
-    isCanonicalExactMoney({ amount: value.amount, currencyCode: 'AUD' }) &&
-    isSortedUniqueHashes(value.componentIds) &&
-    isSortedUniqueHashes(value.evidenceRefIds);
-const isIdentity = (value) => {
-    if (!isFinancialDataflowRecordV1(value) ||
-        !hasFinancialDataflowExactFieldsV1(value, [
-            'schemaVersion',
-            'contractVersion',
-            'baselineId',
-            'ownerScopeId',
-            'period',
-            'costBasis',
-            'estimateLens',
-            'accountingCurrencyCode',
-            'buckets',
-            'reconciliation',
-            'algorithmVersion',
-        ]) ||
-        value.schemaVersion !== FINANCIAL_CHARGE_COMPOSITION_SCHEMA_VERSION_V1 ||
-        value.contractVersion !== FINANCIAL_CHARGE_COMPOSITION_CONTRACT_VERSION_V1 ||
-        !isFinancialDataflowHashV1(value.baselineId) ||
-        !isFinancialDataflowIdentityV1(value.ownerScopeId) ||
-        !isFinancialBaselinePeriodV2(value.period) ||
-        !COST_BASES.has(value.costBasis) ||
-        !ESTIMATE_LENSES.has(value.estimateLens) ||
-        !isFinancialDataflowCurrencyV1(value.accountingCurrencyCode) ||
-        !Array.isArray(value.buckets) ||
-        value.buckets.length === 0 ||
-        value.buckets.length > 20000 ||
-        !value.buckets.every(isBucket) ||
-        !isFinancialDataflowIdentityV1(value.algorithmVersion) ||
-        !isFinancialDataflowRecordV1(value.reconciliation) ||
-        !hasFinancialDataflowExactFieldsV1(value.reconciliation, ['status', 'bucketTotal', 'sourceTotal', 'difference']) ||
-        value.reconciliation.status !== 'reconciled' ||
-        value.reconciliation.difference !== '0' ||
-        !isCanonicalExactMoney({ amount: value.reconciliation.bucketTotal, currencyCode: value.accountingCurrencyCode }) ||
-        !isCanonicalExactMoney({ amount: value.reconciliation.sourceTotal, currencyCode: value.accountingCurrencyCode }))
-        return false;
-    const componentIds = value.buckets.flatMap(bucket => bucket.componentIds);
-    if (new Set(componentIds).size !== componentIds.length)
-        return false;
-    const keys = value.buckets.map(bucket => `${bucket.chargeSource}\u0000${bucket.chargeRecurrence}\u0000${bucket.chargeClassification}`);
-    if (!keys.every((key, index) => index === 0 || keys[index - 1] < key))
-        return false;
-    try {
-        const bucketTotal = formatExactDecimalValue(sumCanonicalDecimals(value.buckets.map(bucket => bucket.amount)));
-        return bucketTotal === value.reconciliation.bucketTotal && bucketTotal === value.reconciliation.sourceTotal;
-    }
-    catch {
-        return false;
-    }
-};
-export const canonicalizeFinancialChargeCompositionIdentityV1 = (value) => {
-    if (!isFinancialDataflowValueWithinLimitsV1(value) || !isIdentity(value)) {
-        throw new TypeError('Invalid FinancialChargeCompositionIdentityPreimageV1.');
-    }
-    return canonicalizeFinancialDataflowJsonV1(value);
-};
-export const createFinancialChargeCompositionIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialChargeCompositionIdentityV1(value))}`;
-export const isFinancialChargeCompositionV1 = (value) => {
-    if (!isFinancialDataflowValueWithinLimitsV1(value) ||
-        !isFinancialDataflowRecordV1(value) ||
-        !hasFinancialDataflowExactFieldsV1(value, [
-            'chargeCompositionId',
-            'schemaVersion',
-            'contractVersion',
-            'baselineId',
-            'ownerScopeId',
-            'period',
-            'costBasis',
-            'estimateLens',
-            'accountingCurrencyCode',
-            'buckets',
-            'reconciliation',
-            'algorithmVersion',
-        ]))
-        return false;
-    const { chargeCompositionId, ...identity } = value;
-    return isFinancialDataflowHashV1(chargeCompositionId) && isIdentity(identity) &&
-        chargeCompositionId === createFinancialChargeCompositionIdV1(identity);
-};
-export const isFinancialChargeInclusionPolicyRefV1 = (value) => isFinancialDataflowRecordV1(value) &&
-    hasFinancialDataflowExactFieldsV1(value, ['policyId', 'policyDigest']) &&
-    isFinancialDataflowIdentityV1(value.policyId) &&
-    isFinancialDataflowHashV1(value.policyDigest) &&
-    resolveFinancialChargeInclusionPolicyV1(value) !== undefined;
-const sumBuckets = (buckets) => formatExactDecimalValue(sumCanonicalDecimals(buckets.map(bucket => bucket.amount)));
-const sourcesFor = (policy, role) => role === 'include' ? policy.includeSources : role === 'exclude' ? policy.excludeSources : policy.withholdSources;
-export const selectFinancialChargesV1 = (composition, policyRef) => {
-    if (!isFinancialChargeCompositionV1(composition))
-        throw new TypeError('Invalid financial charge composition.');
-    const policy = resolveFinancialChargeInclusionPolicyV1(policyRef);
-    if (!policy)
-        throw new TypeError('Unregistered financial charge-inclusion policy.');
-    const partition = (role) => composition.buckets.filter(bucket => sourcesFor(policy, role).includes(bucket.chargeSource));
-    const included = partition('include');
-    const excluded = partition('exclude');
-    const withheld = partition('withhold');
-    if (included.length + excluded.length + withheld.length !== composition.buckets.length) {
-        throw new TypeError('Financial charge-inclusion policy does not partition every charge source.');
-    }
-    const includedAmount = sumBuckets(included);
-    const excludedAmount = sumBuckets(excluded);
-    const withheldAmount = sumBuckets(withheld);
-    const forecastEligibleAmount = sumBuckets(included.filter(bucket => bucket.chargeRecurrence === 'recurring' || bucket.chargeRecurrence === 'usage-based'));
-    const oneTimeAmount = sumBuckets(included.filter(bucket => bucket.chargeRecurrence === 'one-time'));
-    const unknownRecurrenceAmount = sumBuckets(included.filter(bucket => bucket.chargeRecurrence === 'unknown'));
-    const reasonCodes = [];
-    if (withheldAmount !== '0')
-        reasonCodes.push('charge-source-unknown');
-    const forecastReasonCodes = [...reasonCodes];
-    if (unknownRecurrenceAmount !== '0')
-        forecastReasonCodes.push('charge-recurrence-unknown');
-    const result = {
-        status: withheldAmount === '0' ? 'available' : 'partial',
-        includedAmount,
-        excludedAmount,
-        withheldAmount,
-        forecastEligibleAmount,
-        oneTimeAmount,
-        unknownRecurrenceAmount,
-        forecastStatus: withheldAmount === '0' && unknownRecurrenceAmount === '0' ? 'available' : 'partial',
-        currencyCode: composition.accountingCurrencyCode,
-        ...(reasonCodes.length === 0 ? {} : { reasonCodes: reasonCodes }),
-        ...(forecastReasonCodes.length === 0
-            ? {}
-            : { forecastReasonCodes: forecastReasonCodes }),
-    };
-    return result;
-};