@spottoai/types-package 1.0.2-beta.36 → 1.0.2-beta.360

package/dist/esm/azure/billingArtifactCanonicalization.js

@@ -0,0 +1,281 @@
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const requirePlainRecord = (value, name) => {
+    if (!isRecord(value))
+        throw new TypeError(`${name} must be an object.`);
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        throw new TypeError(`${name} must be a plain JSON object.`);
+    if (Object.getOwnPropertySymbols(value).length > 0)
+        throw new TypeError(`${name} cannot contain symbol properties.`);
+    return value;
+};
+const hasUnpairedSurrogate = (value) => {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                return true;
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            return true;
+        }
+    }
+    return false;
+};
+const readDataProperty = (value, key, optional = false) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor === undefined) {
+        if (optional)
+            return undefined;
+        throw new TypeError(`Missing canonical billing field: ${key}`);
+    }
+    if (!('value' in descriptor) || !descriptor.enumerable || descriptor.value === undefined) {
+        throw new TypeError(`Canonical billing field must be an enumerable JSON value: ${key}`);
+    }
+    return descriptor.value;
+};
+const selectOptional = (source, target, key) => {
+    if (hasOwn(source, key))
+        target[key] = readDataProperty(source, key, true);
+};
+const readArrayEntries = (value, name) => {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) {
+        throw new TypeError(`${name} must be a plain JSON array.`);
+    }
+    const ownKeys = Reflect.ownKeys(value);
+    if (ownKeys.some(key => typeof key === 'symbol') ||
+        ownKeys.some(key => typeof key === 'string' && key !== 'length' && !/^(0|[1-9]\d*)$/.test(key))) {
+        throw new TypeError(`${name} cannot contain custom properties.`);
+    }
+    const entries = [];
+    for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (descriptor === undefined || !('value' in descriptor) || !descriptor.enumerable || descriptor.value === undefined) {
+            throw new TypeError(`${name} entries must be enumerable JSON values.`);
+        }
+        entries.push(descriptor.value);
+    }
+    return entries;
+};
+const projectOwnership = (value) => {
+    const source = requirePlainRecord(value, 'Billing output ownership');
+    const projected = {
+        provider: readDataProperty(source, 'provider'),
+        tenantId: readDataProperty(source, 'tenantId'),
+        companyId: readDataProperty(source, 'companyId'),
+        cloudAccountId: readDataProperty(source, 'cloudAccountId'),
+        accountId: readDataProperty(source, 'accountId'),
+    };
+    selectOptional(source, projected, 'ownershipEpochRevision');
+    return projected;
+};
+const projectRevision = (value) => {
+    const source = requirePlainRecord(value, 'Billing output revision');
+    const projected = {
+        sourceRevision: readDataProperty(source, 'sourceRevision'),
+        policyRevision: readDataProperty(source, 'policyRevision'),
+    };
+    selectOptional(source, projected, 'ownershipEpochRevision');
+    return projected;
+};
+const projectIssue = (value) => {
+    const source = requirePlainRecord(value, 'Billing publication issue');
+    const projected = {
+        code: readDataProperty(source, 'code'),
+        blocking: readDataProperty(source, 'blocking'),
+    };
+    selectOptional(source, projected, 'dependency');
+    return projected;
+};
+const projectObservedRange = (value) => {
+    const source = requirePlainRecord(value, 'Billing observed range');
+    const projected = {
+        fromInclusive: readDataProperty(source, 'fromInclusive'),
+        throughExclusive: readDataProperty(source, 'throughExclusive'),
+        dateBasis: readDataProperty(source, 'dateBasis'),
+    };
+    selectOptional(source, projected, 'timeZone');
+    return projected;
+};
+const projectDependency = (value) => {
+    const source = requirePlainRecord(value, 'Billing publication dependency');
+    const projected = {
+        name: readDataProperty(source, 'name'),
+        required: readDataProperty(source, 'required'),
+        support: readDataProperty(source, 'support'),
+        applicability: readDataProperty(source, 'applicability'),
+        attempt: readDataProperty(source, 'attempt'),
+        coverage: readDataProperty(source, 'coverage'),
+        emptyEvidence: readDataProperty(source, 'emptyEvidence'),
+        freshness: readDataProperty(source, 'freshness'),
+        evidence: readDataProperty(source, 'evidence'),
+        publication: readDataProperty(source, 'publication'),
+    };
+    for (const key of [
+        'generationId',
+        'digest',
+        'sourceRevision',
+        'policyRevision',
+        'completeThrough',
+        'emptyProofRef',
+        'reasonCode',
+        'acceptedRowCount',
+    ]) {
+        selectOptional(source, projected, key);
+    }
+    if (hasOwn(source, 'observedRange'))
+        projected.observedRange = projectObservedRange(readDataProperty(source, 'observedRange', true));
+    return projected;
+};
+const projectClaim = (value) => {
+    const source = requirePlainRecord(value, 'Billing publication claim');
+    const sectionPaths = readArrayEntries(readDataProperty(source, 'sectionPaths'), 'Billing claim section paths');
+    const requiredDependencies = readArrayEntries(readDataProperty(source, 'requiredDependencies'), 'Billing claim dependencies');
+    const issues = readArrayEntries(readDataProperty(source, 'issues'), 'Billing claim issues');
+    return {
+        claimId: readDataProperty(source, 'claimId'),
+        sectionPaths: [...sectionPaths],
+        requiredDependencies: [...requiredDependencies],
+        evidence: readDataProperty(source, 'evidence'),
+        publication: readDataProperty(source, 'publication'),
+        issues: issues.map(projectIssue),
+    };
+};
+const projectPublicationDecision = (value) => {
+    const source = requirePlainRecord(value, 'Billing publication decision');
+    const dependencies = readArrayEntries(readDataProperty(source, 'dependencies'), 'Billing publication dependencies');
+    const claims = readArrayEntries(readDataProperty(source, 'claims'), 'Billing publication claims');
+    const issues = readArrayEntries(readDataProperty(source, 'issues'), 'Billing publication issues');
+    return {
+        processing: readDataProperty(source, 'processing'),
+        evidence: readDataProperty(source, 'evidence'),
+        publication: readDataProperty(source, 'publication'),
+        dependencies: dependencies.map(projectDependency),
+        claims: claims.map(projectClaim),
+        issues: issues.map(projectIssue),
+    };
+};
+const projectBinding = (subscriptionId, generationId, ownership, revision, inputManifestDigest, publicationDecision) => ({
+    kind: 'billing-analysis-output',
+    schemaVersion: 1,
+    subscriptionId: subscriptionId,
+    generationId: generationId,
+    ownership: projectOwnership(ownership),
+    revision: projectRevision(revision),
+    inputManifestDigest: inputManifestDigest,
+    publicationDecision: projectPublicationDecision(publicationDecision),
+});
+/** Selects the exact binding-v1 identity/evidence fields from an output manifest. */
+export const projectBillingOutputBindingV1FromManifest = (manifest) => {
+    const value = requirePlainRecord(manifest, 'Billing output manifest');
+    return projectBinding(readDataProperty(value, 'subscriptionId'), readDataProperty(value, 'generationId'), readDataProperty(value, 'ownership'), readDataProperty(value, 'revision'), readDataProperty(value, 'inputManifestDigest'), readDataProperty(value, 'publicationDecision'));
+};
+/** Selects the exact binding-v1 identity/evidence fields from billing metadata. */
+export const projectBillingOutputBindingV1FromMetadata = (metadata) => {
+    const value = requirePlainRecord(metadata, 'Billing cost metadata');
+    return projectBinding(readDataProperty(value, 'subscriptionId'), readDataProperty(value, 'billingGenerationId'), readDataProperty(value, 'ownership'), readDataProperty(value, 'revision'), readDataProperty(value, 'inputManifestDigest'), readDataProperty(value, 'artifactEvidence'));
+};
+const canonicalizeJson = (value) => {
+    const active = new Set();
+    const serialize = (candidate) => {
+        if (candidate === null || typeof candidate === 'boolean')
+            return JSON.stringify(candidate);
+        if (typeof candidate === 'string') {
+            if (hasUnpairedSurrogate(candidate))
+                throw new TypeError('Canonical JSON rejects invalid Unicode surrogate data.');
+            return JSON.stringify(candidate);
+        }
+        if (typeof candidate === 'number') {
+            if (!Number.isFinite(candidate) || Object.is(candidate, -0) || (Number.isInteger(candidate) && !Number.isSafeInteger(candidate))) {
+                throw new TypeError('Canonical JSON requires finite, safe, non-negative-zero numbers.');
+            }
+            return JSON.stringify(candidate);
+        }
+        if (typeof candidate !== 'object' || candidate === undefined)
+            throw new TypeError('Canonical JSON rejects non-JSON values.');
+        if (active.has(candidate))
+            throw new TypeError('Canonical JSON rejects cyclic values.');
+        active.add(candidate);
+        try {
+            if (Array.isArray(candidate)) {
+                if (Object.getPrototypeOf(candidate) !== Array.prototype)
+                    throw new TypeError('Canonical JSON requires plain arrays.');
+                const ownKeys = Reflect.ownKeys(candidate);
+                if (ownKeys.some(key => typeof key === 'symbol') ||
+                    ownKeys.some(key => typeof key === 'string' && key !== 'length' && !/^(0|[1-9]\d*)$/.test(key))) {
+                    throw new TypeError('Canonical JSON arrays cannot contain custom properties.');
+                }
+                const values = [];
+                for (let index = 0; index < candidate.length; index += 1) {
+                    if (!hasOwn(candidate, index))
+                        throw new TypeError('Canonical JSON rejects sparse arrays.');
+                    const descriptor = Object.getOwnPropertyDescriptor(candidate, String(index));
+                    if (descriptor === undefined || !('value' in descriptor) || !descriptor.enumerable || descriptor.value === undefined) {
+                        throw new TypeError('Canonical JSON array entries must be enumerable JSON values.');
+                    }
+                    values.push(serialize(descriptor.value));
+                }
+                return `[${values.join(',')}]`;
+            }
+            const prototype = Object.getPrototypeOf(candidate);
+            if (prototype !== Object.prototype && prototype !== null)
+                throw new TypeError('Canonical JSON requires plain objects.');
+            if (Object.getOwnPropertySymbols(candidate).length > 0)
+                throw new TypeError('Canonical JSON rejects symbol properties.');
+            const entries = [];
+            for (const key of Object.getOwnPropertyNames(candidate).sort()) {
+                if (hasUnpairedSurrogate(key))
+                    throw new TypeError('Canonical JSON rejects invalid Unicode property names.');
+                const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+                if (descriptor === undefined || !('value' in descriptor) || !descriptor.enumerable || descriptor.value === undefined) {
+                    throw new TypeError('Canonical JSON object fields must be enumerable JSON values.');
+                }
+                entries.push(`${JSON.stringify(key)}:${serialize(descriptor.value)}`);
+            }
+            return `{${entries.join(',')}}`;
+        }
+        finally {
+            active.delete(candidate);
+        }
+    };
+    return serialize(value);
+};
+const withoutManifestDigest = (manifest) => {
+    const prototype = Object.getPrototypeOf(manifest);
+    if (prototype !== Object.prototype && prototype !== null)
+        throw new TypeError('Canonical manifests must be plain objects.');
+    const digestDescriptor = Object.getOwnPropertyDescriptor(manifest, 'manifestDigest');
+    if (digestDescriptor === undefined || !('value' in digestDescriptor) || typeof digestDescriptor.value !== 'string') {
+        throw new TypeError('Canonical manifests require a top-level manifestDigest string.');
+    }
+    const preimage = {};
+    for (const key of Reflect.ownKeys(manifest)) {
+        if (typeof key !== 'string')
+            throw new TypeError('Canonical manifests reject symbol properties.');
+        if (key === 'manifestDigest')
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(manifest, key);
+        if (descriptor === undefined || !('value' in descriptor) || !descriptor.enumerable || descriptor.value === undefined) {
+            throw new TypeError('Canonical manifest fields must be enumerable JSON values.');
+        }
+        preimage[key] = descriptor.value;
+    }
+    return preimage;
+};
+/** Returns the RFC 8785/JCS-compatible UTF-8 preimage for billing output binding SHA-256 B. */
+export const canonicalizeBillingOutputBindingV1 = (binding) => {
+    const value = requirePlainRecord(binding, 'Billing output binding');
+    if (readDataProperty(value, 'kind') !== 'billing-analysis-output' || readDataProperty(value, 'schemaVersion') !== 1) {
+        throw new TypeError('Billing output binding requires its version-1 domain separator.');
+    }
+    return canonicalizeJson(projectBinding(readDataProperty(value, 'subscriptionId'), readDataProperty(value, 'generationId'), readDataProperty(value, 'ownership'), readDataProperty(value, 'revision'), readDataProperty(value, 'inputManifestDigest'), readDataProperty(value, 'publicationDecision')));
+};
+/** Returns the canonical input-manifest digest preimage, excluding only top-level manifestDigest. */
+export const canonicalizeBillingAnalyzerInputManifestV2ForDigest = (manifest) => canonicalizeJson(withoutManifestDigest(manifest));
+/** Returns the canonical output-manifest digest preimage, excluding only top-level manifestDigest. */
+export const canonicalizeBillingAnalyzerOutputManifestV2ForDigest = (manifest) => canonicalizeJson(withoutManifestDigest(manifest));
+/** Returns the RFC 8785/JCS-compatible canonical JSON string for a validated JSON value. */
+export const canonicalizeBillingArtifactJson = (value) => canonicalizeJson(value);

package/dist/esm/azure/billingArtifactEvidence.js

@@ -0,0 +1,23 @@
+import { isArtifactPublicationDecision, } from '../common/artifactEvidence.js';
+const hasBillingArtifactAuthority = (value, generationId, inputManifestDigest) => {
+    const billingHistory = value.dependencies[0];
+    const costAnalysis = value.claims[0];
+    return (billingHistory?.name === 'billing-history' &&
+        billingHistory.required === true &&
+        billingHistory.publication === 'completed' &&
+        billingHistory.generationId === generationId &&
+        billingHistory.digest === inputManifestDigest &&
+        costAnalysis?.claimId === 'cost-analysis' &&
+        costAnalysis.requiredDependencies[0] === 'billing-history');
+};
+/** Validates the exact completed billing dependency and claim bound to one input generation. */
+export const isBillingCompletedArtifactPublicationDecision = (value, generationId, inputManifestDigest) => {
+    if (!isArtifactPublicationDecision(value) || value.publication !== 'completed')
+        return false;
+    return value.claims[0]?.publication === 'completed' && hasBillingArtifactAuthority(value, generationId, inputManifestDigest);
+};
+/** Validates partial billing evidence bound to one authoritative input generation. */
+export const isBillingPartialArtifactPublicationDecision = (value, generationId, inputManifestDigest) => isArtifactPublicationDecision(value) &&
+    value.evidence === 'partial' &&
+    (value.publication === 'completed' || value.publication === 'partial') &&
+    hasBillingArtifactAuthority(value, generationId, inputManifestDigest);

package/dist/esm/azure/billingArtifactGeneration.js

@@ -0,0 +1,229 @@
+import { isArtifactOwnershipBinding, isEnforceableArtifactOwnershipBinding, } from '../common/artifactEvidence.js';
+import { isArtifactRevisionVector, isStrictLogicalArtifactReference } from '../common/artifactEvidenceValidation.js';
+import { allowedArtifactIdentityField, allowedArtifactReferenceField, containsForbiddenArtifactControlData, } from '../common/artifactControlData.js';
+import { isBillingCompletedArtifactPublicationDecision } from './billingArtifactEvidence.js';
+const BILLING_BASES = new Set(['actual', 'amortized']);
+const COVERAGE_VERDICTS = new Set(['complete', 'partial', 'none', 'unknown']);
+const DATE_BASES = new Set(['utc', 'billing-calendar', 'company-local']);
+const CONTENT_ENCODINGS = new Set(['identity', 'gzip']);
+const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isNonEmptyString = (value) => typeof value === 'string' && value.trim() === value && value.length > 0;
+const isPositiveInteger = (value) => Number.isSafeInteger(value) && Number(value) > 0;
+const isNonNegativeInteger = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+const isStringIn = (value, values) => typeof value === 'string' && values.has(value);
+const hasUniqueValues = (values) => new Set(values).size === values.length;
+const publicationDecisionReferencesDigest = (value, digests) => isRecord(value) &&
+    Array.isArray(value.dependencies) &&
+    value.dependencies.some(dependency => isRecord(dependency) && typeof dependency.digest === 'string' && digests.has(dependency.digest));
+const isCanonicalIsoTimestamp = (value) => {
+    if (!isNonEmptyString(value))
+        return false;
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
+};
+const hasControlCharacters = (value) => Array.from(value).some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127);
+const allowedDescriptorPaths = (descriptors) => Array.isArray(descriptors) ? descriptors.flatMap(descriptor => allowedArtifactReferenceField(descriptor, 'path')) : [];
+const isPathSegment = (value) => isNonEmptyString(value) && !/[\\/?#%]/.test(value) && !hasControlCharacters(value) && value !== '.' && value !== '..';
+const inputGenerationPrefix = (subscriptionId, generationId) => `subscriptions/${subscriptionId}/history/billing/analyzer-inputs/generations/${generationId}/`;
+const inputManifestPath = (subscriptionId, generationId) => `${inputGenerationPrefix(subscriptionId, generationId)}manifest.json`;
+const outputGenerationPrefix = (subscriptionId, generationId) => `subscriptions/${subscriptionId}/billing/generations/${generationId}/`;
+const outputManifestPath = (subscriptionId, generationId) => `${outputGenerationPrefix(subscriptionId, generationId)}manifest.json`;
+const isGenerationPath = (value, prefix, forbiddenExactPath) => isStrictLogicalArtifactReference(value) && value.startsWith(prefix) && value.length > prefix.length && value !== forbiddenExactPath;
+const hasMatchingIdentity = (subscriptionId, generationId, ownership, revision, enforceable) => {
+    if (!isPathSegment(subscriptionId) ||
+        !isPathSegment(generationId) ||
+        !isArtifactOwnershipBinding(ownership) ||
+        !isArtifactRevisionVector(revision)) {
+        return false;
+    }
+    if (ownership.provider !== 'azure' || ownership.accountId !== subscriptionId)
+        return false;
+    if (ownership.ownershipEpochRevision !== revision.ownershipEpochRevision)
+        return false;
+    return !enforceable || isEnforceableArtifactOwnershipBinding(ownership);
+};
+const isSha256 = (value) => typeof value === 'string' && SHA256_PATTERN.test(value);
+const isRequestedPeriod = (value) => {
+    if (!isRecord(value) ||
+        !isCanonicalIsoTimestamp(value.fromInclusive) ||
+        !isCanonicalIsoTimestamp(value.throughExclusive) ||
+        Date.parse(value.throughExclusive) <= Date.parse(value.fromInclusive) ||
+        !isStringIn(value.dateBasis, DATE_BASES) ||
+        !isStringIn(value.basis, BILLING_BASES)) {
+        return false;
+    }
+    return value.timeZone === undefined || isNonEmptyString(value.timeZone);
+};
+const isInputObjectDescriptor = (value, subscriptionId, generationId) => {
+    if (!isRecord(value))
+        return false;
+    const prefix = inputGenerationPrefix(subscriptionId, generationId);
+    return (isGenerationPath(value.path, prefix, inputManifestPath(subscriptionId, generationId)) &&
+        (value.versionId === undefined || isNonEmptyString(value.versionId)) &&
+        isNonEmptyString(value.etag) &&
+        isSha256(value.sha256) &&
+        isPositiveInteger(value.byteCount) &&
+        isNonNegativeInteger(value.rowCount) &&
+        isStringIn(value.basis, BILLING_BASES) &&
+        (value.currencyCode === undefined || isNonEmptyString(value.currencyCode)) &&
+        isStringIn(value.coverage, COVERAGE_VERDICTS));
+};
+const isOutputArtifactDescriptor = (value, subscriptionId, generationId) => {
+    if (!isRecord(value))
+        return false;
+    const prefix = outputGenerationPrefix(subscriptionId, generationId);
+    return (isGenerationPath(value.path, prefix, outputManifestPath(subscriptionId, generationId)) &&
+        isNonEmptyString(value.name) &&
+        value.mediaType === 'application/json' &&
+        isStringIn(value.contentEncoding, CONTENT_ENCODINGS) &&
+        isNonNegativeInteger(value.byteLength) &&
+        isSha256(value.sha256));
+};
+const isJsonMetadata = (value) => {
+    if (!isRecord(value))
+        return false;
+    const visit = (candidate) => {
+        if (candidate === null || typeof candidate === 'string' || typeof candidate === 'boolean')
+            return true;
+        if (isFiniteNumber(candidate))
+            return true;
+        if (Array.isArray(candidate))
+            return candidate.every(visit);
+        return isRecord(candidate) && Object.getPrototypeOf(candidate) === Object.prototype && Object.values(candidate).every(visit);
+    };
+    return visit(value);
+};
+/** Validates one immutable billing analyzer input manifest without performing I/O. */
+export const isBillingAnalyzerInputManifestV2 = (value) => {
+    if (!isRecord(value) ||
+        containsForbiddenArtifactControlData(value, [...allowedArtifactIdentityField(value, 'publicationKey'), ...allowedDescriptorPaths(value.inputs)])) {
+        return false;
+    }
+    if (value.schemaVersion !== 2 || value.status !== 'completed')
+        return false;
+    if (!hasMatchingIdentity(value.subscriptionId, value.generationId, value.ownership, value.revision, false))
+        return false;
+    if (!isNonEmptyString(value.publicationKey) || !isSha256(value.coveragePlanDigest) || !isSha256(value.manifestDigest))
+        return false;
+    if (!isCanonicalIsoTimestamp(value.asOfUtc) || !isCanonicalIsoTimestamp(value.stableCutoffUtc) || !isCanonicalIsoTimestamp(value.completedAt)) {
+        return false;
+    }
+    if (Date.parse(value.stableCutoffUtc) > Date.parse(value.asOfUtc) || Date.parse(value.completedAt) < Date.parse(value.asOfUtc))
+        return false;
+    if (!Array.isArray(value.requestedPeriods) || value.requestedPeriods.length === 0 || !value.requestedPeriods.every(isRequestedPeriod))
+        return false;
+    const periodKeys = value.requestedPeriods.map(period => `${period.fromInclusive}\n${period.throughExclusive}\n${period.dateBasis}\n${period.timeZone ?? ''}\n${period.basis}`);
+    if (!hasUniqueValues(periodKeys))
+        return false;
+    if (!Array.isArray(value.inputs) || value.inputs.length === 0)
+        return false;
+    if (!value.inputs.every(input => isInputObjectDescriptor(input, value.subscriptionId, value.generationId)))
+        return false;
+    return hasUniqueValues(value.inputs.map(input => input.path));
+};
+/** Validates the enforceable current pointer for one published analyzer input generation. */
+export const isBillingAnalyzerInputCurrentPointerV1 = (value) => {
+    if (!isRecord(value) || containsForbiddenArtifactControlData(value, allowedArtifactReferenceField(value, 'manifestPath')))
+        return false;
+    if (value.schemaVersion !== 1 || value.status !== 'completed')
+        return false;
+    if (!hasMatchingIdentity(value.subscriptionId, value.generationId, value.ownership, value.revision, true))
+        return false;
+    return (isStrictLogicalArtifactReference(value.manifestPath) &&
+        value.manifestPath === inputManifestPath(value.subscriptionId, value.generationId) &&
+        isSha256(value.manifestDigest) &&
+        isCanonicalIsoTimestamp(value.completedAt));
+};
+/** Validates the V2 queue envelope and its immutable input-manifest binding. */
+export const isBillingAnalyzerRequestV2 = (value) => {
+    if (!isRecord(value) || containsForbiddenArtifactControlData(value, allowedArtifactReferenceField(value, 'inputManifestPath')))
+        return false;
+    if (value.schemaVersion !== 2 || (value.publicationMode !== 'observe' && value.publicationMode !== 'enforce'))
+        return false;
+    const enforceable = value.publicationMode === 'enforce';
+    if (!hasMatchingIdentity(value.subscriptionId, value.generationId, value.ownership, value.revision, enforceable))
+        return false;
+    if (![value.eventId, value.correlationId].every(isNonEmptyString) || !isSha256(value.messageId) || !isSha256(value.idempotencyKey))
+        return false;
+    if (value.idempotencyKey !== value.messageId || !isCanonicalIsoTimestamp(value.occurredAt))
+        return false;
+    if (!isStrictLogicalArtifactReference(value.inputManifestPath) ||
+        value.inputManifestPath !== inputManifestPath(value.subscriptionId, value.generationId)) {
+        return false;
+    }
+    if (!isSha256(value.inputManifestDigest))
+        return false;
+    return value.displayMetadata === undefined || isJsonMetadata(value.displayMetadata);
+};
+/** Validates an immutable analyzer output manifest and its exact input binding. */
+export const isBillingAnalyzerOutputManifestV2 = (value) => {
+    if (!isRecord(value) ||
+        containsForbiddenArtifactControlData(value, [
+            ...allowedArtifactReferenceField(value, 'inputManifestPath'),
+            ...allowedDescriptorPaths(value.artifacts),
+        ])) {
+        return false;
+    }
+    if (value.schemaVersion !== 2 || value.status !== 'completed')
+        return false;
+    if (!hasMatchingIdentity(value.subscriptionId, value.generationId, value.ownership, value.revision, false))
+        return false;
+    if (!isStrictLogicalArtifactReference(value.inputManifestPath) ||
+        value.inputManifestPath !== inputManifestPath(value.subscriptionId, value.generationId)) {
+        return false;
+    }
+    if (!isSha256(value.inputManifestDigest) || !isSha256(value.outputBindingDigest) || !isSha256(value.manifestDigest))
+        return false;
+    if (!Array.isArray(value.artifacts) || value.artifacts.length === 0)
+        return false;
+    if (!value.artifacts.every(artifact => isOutputArtifactDescriptor(artifact, value.subscriptionId, value.generationId))) {
+        return false;
+    }
+    if (!hasUniqueValues(value.artifacts.map(artifact => artifact.path)) || !hasUniqueValues(value.artifacts.map(artifact => artifact.name)))
+        return false;
+    const outputDerivedDigests = new Set([
+        value.inputManifestDigest,
+        value.outputBindingDigest,
+        value.manifestDigest,
+        ...value.artifacts.map(artifact => artifact.sha256),
+    ]);
+    if (value.outputBindingDigest === value.inputManifestDigest ||
+        value.outputBindingDigest === value.manifestDigest ||
+        value.artifacts.some(artifact => artifact.sha256 === value.outputBindingDigest || artifact.sha256 === value.manifestDigest) ||
+        publicationDecisionReferencesDigest(value.publicationDecision, new Set([...outputDerivedDigests].filter(digest => digest !== value.inputManifestDigest)))) {
+        return false;
+    }
+    if (!value.artifacts.some(artifact => artifact.path === `${outputGenerationPrefix(value.subscriptionId, value.generationId)}metadata.json`)) {
+        return false;
+    }
+    return (isBillingCompletedArtifactPublicationDecision(value.publicationDecision, value.generationId, value.inputManifestDigest) &&
+        isCanonicalIsoTimestamp(value.completedAt));
+};
+/** Validates the sole promoted authority pointer for completed billing analysis. */
+export const isBillingAnalysisCurrentPointerV1 = (value) => {
+    if (!isRecord(value) ||
+        containsForbiddenArtifactControlData(value, [
+            ...allowedArtifactReferenceField(value, 'inputManifestPath'),
+            ...allowedArtifactReferenceField(value, 'outputManifestPath'),
+        ])) {
+        return false;
+    }
+    if (value.schemaVersion !== 1 || value.status !== 'completed')
+        return false;
+    if (!hasMatchingIdentity(value.subscriptionId, value.generationId, value.ownership, value.revision, true))
+        return false;
+    if (!isStrictLogicalArtifactReference(value.inputManifestPath) ||
+        value.inputManifestPath !== inputManifestPath(value.subscriptionId, value.generationId)) {
+        return false;
+    }
+    if (!isStrictLogicalArtifactReference(value.outputManifestPath) ||
+        value.outputManifestPath !== outputManifestPath(value.subscriptionId, value.generationId)) {
+        return false;
+    }
+    if (!isSha256(value.inputManifestDigest) || !isSha256(value.outputManifestDigest))
+        return false;
+    return (isBillingCompletedArtifactPublicationDecision(value.publicationDecision, value.generationId, value.inputManifestDigest) &&
+        isCanonicalIsoTimestamp(value.completedAt));
+};

package/dist/esm/azure/billingGeneration.js

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