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

package/dist/esm/azure/billingPlots.js

@@ -0,0 +1,470 @@
+/**
+ * Billing cost analysis types for Azure cost visualization.
+ */
+import { isArtifactOwnershipBinding } from '../common/artifactEvidence.js';
+import { containsForbiddenArtifactControlData } from '../common/artifactControlData.js';
+import { isArtifactRevisionVector } from '../common/artifactEvidenceValidation.js';
+import { isBillingCompletedArtifactPublicationDecision, isBillingPartialArtifactPublicationDecision, } from './billingArtifactEvidence.js';
+const LEGACY_FALLBACK_FORBIDDEN_OWN_FIELDS = [
+    'schemaVersion',
+    'ownership',
+    'revision',
+    'authority',
+    'documentType',
+    'publicationMode',
+    'status',
+    'generationId',
+    'inputManifestDigest',
+    'outputBindingDigest',
+    'outputManifestDigest',
+    'manifestDigest',
+    'observationDigest',
+    'sha256',
+    'artifactEvidence',
+    'publicationDecision',
+    'artifacts',
+    'manifestPath',
+    'inputManifestPath',
+    'outputManifestPath',
+    'byteLength',
+    'byteCount',
+    'rowCount',
+    'contentEncoding',
+    'mediaType',
+    'etag',
+    'versionId',
+    'publicationKey',
+    'coveragePlanDigest',
+    'messageId',
+    'eventId',
+    'correlationId',
+    'idempotencyKey',
+    'inputState',
+    'processingState',
+    'evaluation',
+    'dependencies',
+    'claims',
+    'issues',
+    'completedAt',
+    'observedAt',
+    'enqueuedAt',
+];
+const BILLING_FORBIDDEN_CONTROL_FIELDS = new Set([
+    ...LEGACY_FALLBACK_FORBIDDEN_OWN_FIELDS,
+    'artifactState',
+    'artifactSource',
+    'digest',
+    'fingerprint',
+    'checksum',
+    'hash',
+    'subscriptionId',
+    'provider',
+    'tenantId',
+    'companyId',
+    'cloudAccountId',
+    'accountId',
+    'ownershipEpochRevision',
+    'sourceRevision',
+    'policyRevision',
+    'processing',
+    'evidence',
+    'publication',
+    'required',
+    'support',
+    'applicability',
+    'attempt',
+    'coverage',
+    'emptyEvidence',
+    'freshness',
+    'reasonCode',
+    'acceptedRowCount',
+    'emptyProofRef',
+    'claimId',
+    'sectionPaths',
+    'requiredDependencies',
+    'code',
+    'blocking',
+    'dependency',
+].map(field => field.toLowerCase()));
+const BILLING_DOCUMENT_STATES = new Set(['current', 'stale', 'partial', 'complete-empty']);
+const BILLING_VERIFIED_READ_STATES = new Set(['current', 'stale', 'complete-empty']);
+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 isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+const isOptionalFiniteNumber = (value) => value === undefined || isFiniteNumber(value);
+const isNullableFiniteNumber = (value) => value === null || isFiniteNumber(value);
+const isNonNegativeInteger = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
+const isPositiveInteger = (value) => Number.isSafeInteger(value) && Number(value) > 0;
+const isStringArray = (value) => Array.isArray(value) && value.every(isNonEmptyString);
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const hasControlCharacters = (value) => Array.from(value).some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127);
+const isPathSegment = (value) => isNonEmptyString(value) && !/[\\/?#%]/.test(value) && !hasControlCharacters(value) && value !== '.' && value !== '..';
+const publicationDecisionReferencesDigest = (value, digest) => isRecord(value) && Array.isArray(value.dependencies) && value.dependencies.some(dependency => isRecord(dependency) && dependency.digest === digest);
+const allowedBillingCostAnalysisFields = (value, validationBranch) => {
+    const fields = [];
+    const allowText = (object, ...keys) => {
+        if (!isRecord(object))
+            return;
+        for (const key of keys)
+            fields.push({ object, key, allowUriScheme: true, allowDigestLike: true, allowControlField: true });
+    };
+    const allowTextArray = (object, key) => {
+        if (isRecord(object)) {
+            fields.push({ object, key, allowUriSchemeInStringArray: true, allowDigestLike: true, allowControlField: true });
+        }
+    };
+    const allowControl = (object, ...keys) => {
+        if (!isRecord(object))
+            return;
+        for (const key of keys)
+            fields.push({ object, key, allowControlField: true });
+    };
+    const allowDigest = (object, key) => {
+        if (isRecord(object))
+            fields.push({ object, key, allowDigestLike: true, allowControlField: true });
+    };
+    const allowChildren = (object, ...keys) => {
+        if (!isRecord(object))
+            return;
+        for (const key of keys)
+            fields.push({ object, key, allowChildArtifactFields: true });
+    };
+    allowText(value, 'subscriptionId', 'billingGenerationId', 'currencyCode', 'currencySymbol', 'forecastMethod');
+    allowControl(value, 'schemaVersion', 'ownership', 'revision', 'artifactEvidence');
+    allowChildren(value, 'ownership', 'revision', 'artifactEvidence', 'chartData', 'anomalies');
+    if (validationBranch !== 'business-v1')
+        allowControl(value, 'artifactState');
+    if (validationBranch === 'legacy-fallback')
+        allowControl(value, 'artifactSource');
+    allowDigest(value, 'inputManifestDigest');
+    allowDigest(value, 'outputBindingDigest');
+    if (isRecord(value.ownership)) {
+        allowControl(value.ownership, 'provider', 'ownershipEpochRevision');
+        allowText(value.ownership, 'tenantId', 'companyId', 'cloudAccountId', 'accountId');
+    }
+    if (isRecord(value.revision))
+        allowControl(value.revision, 'ownershipEpochRevision', 'sourceRevision', 'policyRevision');
+    if (isRecord(value.artifactEvidence)) {
+        const evidence = value.artifactEvidence;
+        allowControl(evidence, 'processing', 'evidence', 'publication', 'dependencies', 'claims', 'issues');
+        allowChildren(evidence, 'dependencies', 'claims', 'issues');
+        if (Array.isArray(evidence.dependencies)) {
+            for (const dependency of evidence.dependencies) {
+                allowControl(dependency, 'required', 'support', 'applicability', 'attempt', 'coverage', 'emptyEvidence', 'freshness', 'evidence', 'publication', 'sourceRevision', 'policyRevision', 'acceptedRowCount', 'emptyProofRef');
+                allowText(dependency, 'name', 'reasonCode', 'generationId');
+                allowDigest(dependency, 'digest');
+                if (isRecord(dependency) && isRecord(dependency.observedRange)) {
+                    allowChildren(dependency, 'observedRange');
+                    allowText(dependency.observedRange, 'timeZone');
+                }
+            }
+        }
+        if (Array.isArray(evidence.claims)) {
+            for (const claim of evidence.claims) {
+                allowControl(claim, 'evidence', 'publication', 'issues');
+                allowText(claim, 'claimId');
+                allowTextArray(claim, 'sectionPaths');
+                allowTextArray(claim, 'requiredDependencies');
+                if (!isRecord(claim) || !Array.isArray(claim.issues))
+                    continue;
+                allowChildren(claim, 'issues');
+                for (const issue of claim.issues) {
+                    allowControl(issue, 'blocking');
+                    allowText(issue, 'code', 'dependency');
+                }
+            }
+        }
+        if (Array.isArray(evidence.issues)) {
+            for (const issue of evidence.issues) {
+                allowControl(issue, 'blocking');
+                allowText(issue, 'code', 'dependency');
+            }
+        }
+    }
+    if (isRecord(value.chartData)) {
+        allowControl(value.chartData, 'schemaVersion');
+        allowText(value.chartData, 'source');
+        allowChildren(value.chartData, 'dataWindow', 'views', 'detectors');
+        if (isRecord(value.chartData.views)) {
+            for (const [viewKey, view] of Object.entries(value.chartData.views)) {
+                allowChildren(value.chartData.views, viewKey);
+                allowText(view, 'aggregation', 'forecastMethod');
+                if (!isRecord(view))
+                    continue;
+                allowChildren(view, 'trend', 'points', 'actualPoints', 'forecastPoints', 'fittedPoints');
+                allowText(view.trend, 'method');
+                for (const pointsKey of ['points', 'actualPoints', 'forecastPoints', 'fittedPoints']) {
+                    const points = view[pointsKey];
+                    if (!Array.isArray(points))
+                        continue;
+                    for (const point of points) {
+                        allowText(point, 'date', 'month');
+                        allowTextArray(point, 'anomalyMethods');
+                    }
+                }
+            }
+        }
+        if (isRecord(value.chartData.detectors) && Array.isArray(value.chartData.detectors.methods)) {
+            allowChildren(value.chartData.detectors, 'methods');
+            for (const method of value.chartData.detectors.methods)
+                allowText(method, 'name', 'status', 'error');
+        }
+    }
+    if (!Array.isArray(value.anomalies))
+        return fields;
+    for (const anomaly of value.anomalies) {
+        allowText(anomaly, 'summary', 'confidence');
+        allowTextArray(anomaly, 'notes');
+        if (!isRecord(anomaly) || !Array.isArray(anomaly.drivers))
+            continue;
+        allowChildren(anomaly, 'impact', 'drivers');
+        for (const driver of anomaly.drivers) {
+            allowText(driver, 'type', 'name', 'summary');
+            if (!isRecord(driver) || !Array.isArray(driver.resources))
+                continue;
+            allowChildren(driver, 'resources');
+            for (const resource of driver.resources)
+                allowText(resource, 'name', 'resourceScope', 'summary');
+        }
+    }
+    return fields;
+};
+const containsForbiddenBillingCostAnalysisControlData = (value, validationBranch) => containsForbiddenArtifactControlData(value, allowedBillingCostAnalysisFields(value, validationBranch), {
+    rejectDigestLikeValues: true,
+    requireSafeAzureResourceIds: true,
+    forbiddenControlFields: BILLING_FORBIDDEN_CONTROL_FIELDS,
+    requireAllowedFieldTraversalContext: true,
+});
+const isTrend = (value) => isRecord(value) && isNonEmptyString(value.method) && isFiniteNumber(value.slope) && isFiniteNumber(value.intercept);
+const isDailyPoint = (value) => isRecord(value) &&
+    isNonEmptyString(value.date) &&
+    isFiniteNumber(value.timestamp) &&
+    isFiniteNumber(value.cost) &&
+    typeof value.isAnomaly === 'boolean' &&
+    isNonNegativeInteger(value.anomalyVotes) &&
+    isOptionalFiniteNumber(value.trendCost) &&
+    (value.anomalyMethods === undefined || isStringArray(value.anomalyMethods));
+const isForecastPoint = (value) => isRecord(value) &&
+    isNonEmptyString(value.date) &&
+    isFiniteNumber(value.timestamp) &&
+    isFiniteNumber(value.cost) &&
+    isOptionalFiniteNumber(value.trendCost);
+const isMonthlyPoint = (value) => isRecord(value) &&
+    /^\d{4}-\d{2}$/.test(String(value.month)) &&
+    isFiniteNumber(value.startDate) &&
+    isFiniteNumber(value.endDate) &&
+    isFiniteNumber(value.cost) &&
+    isFiniteNumber(value.averageDailyCost) &&
+    isNonNegativeInteger(value.anomalyCount) &&
+    isOptionalFiniteNumber(value.trendCost) &&
+    (value.anomalyDates === undefined || (Array.isArray(value.anomalyDates) && value.anomalyDates.every(isFiniteNumber)));
+const hasCommonChartViewFields = (value) => isFiniteNumber(value.startDate) &&
+    isFiniteNumber(value.endDate) &&
+    isFiniteNumber(value.averageDailyCost) &&
+    isFiniteNumber(value.totalCost) &&
+    (value.trend === undefined || isTrend(value.trend));
+const isChartView = (value) => {
+    if (!isRecord(value) || (value.trend !== undefined && !isTrend(value.trend)))
+        return false;
+    if (value.forecastMethod !== undefined) {
+        return (value.aggregation === 'daily' &&
+            isNonEmptyString(value.forecastMethod) &&
+            [value.startDate, value.endDate, value.actualTotalCost, value.forecastRemaining, value.forecastMonthTotal].every(isFiniteNumber) &&
+            Array.isArray(value.actualPoints) &&
+            value.actualPoints.every(isDailyPoint) &&
+            Array.isArray(value.forecastPoints) &&
+            value.forecastPoints.every(isForecastPoint) &&
+            Array.isArray(value.fittedPoints) &&
+            value.fittedPoints.every(isForecastPoint));
+    }
+    if (!hasCommonChartViewFields(value) || !Array.isArray(value.points))
+        return false;
+    if (value.aggregation === 'daily')
+        return value.points.every(isDailyPoint);
+    if (value.aggregation === 'monthly')
+        return value.points.every(isMonthlyPoint);
+    return false;
+};
+const isChartData = (value) => {
+    if (!isRecord(value) || !isPositiveInteger(value.schemaVersion) || !isNonEmptyString(value.source))
+        return false;
+    if (!isRecord(value.dataWindow) ||
+        !isFiniteNumber(value.dataWindow.startDate) ||
+        !isFiniteNumber(value.dataWindow.endDate) ||
+        !isNonNegativeInteger(value.dataWindow.pointCount)) {
+        return false;
+    }
+    if (!isRecord(value.views) || !Object.values(value.views).every(view => view === undefined || isChartView(view)))
+        return false;
+    if (!isRecord(value.detectors) || !isFiniteNumber(value.detectors.threshold) || !Array.isArray(value.detectors.methods))
+        return false;
+    return value.detectors.methods.every(method => isRecord(method) &&
+        isNonEmptyString(method.name) &&
+        (method.status === undefined || isNonEmptyString(method.status)) &&
+        (method.error === undefined || method.error === null || typeof method.error === 'string') &&
+        Array.isArray(method.triggeredDates) &&
+        method.triggeredDates.every(isFiniteNumber));
+};
+const isDriverResource = (value) => isRecord(value) &&
+    isNonEmptyString(value.name) &&
+    (value.resourceScope === undefined || isNonEmptyString(value.resourceScope)) &&
+    (value.resourceId === undefined || isNonEmptyString(value.resourceId)) &&
+    (value.isSubscriptionLevel === undefined || typeof value.isSubscriptionLevel === 'boolean') &&
+    isFiniteNumber(value.cost) &&
+    isNullableFiniteNumber(value.baseline) &&
+    isFiniteNumber(value.delta) &&
+    isNullableFiniteNumber(value.percentChange) &&
+    typeof value.isNew === 'boolean' &&
+    isNonEmptyString(value.summary);
+const isAnomaly = (value) => {
+    if (!isRecord(value) || !isFiniteNumber(value.date) || !isNonEmptyString(value.summary) || !isNonEmptyString(value.confidence))
+        return false;
+    if (!isStringArray(value.notes) || !isRecord(value.impact) || !Array.isArray(value.drivers))
+        return false;
+    const impact = value.impact;
+    const impactRequired = ['cost', 'delta', 'monthToDateCost'];
+    const impactNullable = [
+        'baseline7Day',
+        'baseline30Day',
+        'percentChange',
+        'previousDayCost',
+        'previousDayDelta',
+        'monthToDateBaseline',
+        'monthToDateDelta',
+        'monthToDatePercentChange',
+    ];
+    if (!impactRequired.every(field => isFiniteNumber(impact[field])) || !impactNullable.every(field => isNullableFiniteNumber(impact[field]))) {
+        return false;
+    }
+    return value.drivers.every(driver => isRecord(driver) &&
+        isNonEmptyString(driver.type) &&
+        isNonEmptyString(driver.name) &&
+        isNonEmptyString(driver.summary) &&
+        isFiniteNumber(driver.cost) &&
+        isFiniteNumber(driver.delta) &&
+        isNullableFiniteNumber(driver.baseline) &&
+        isNullableFiniteNumber(driver.percentChange) &&
+        isFiniteNumber(driver.shareOfImpactPercent) &&
+        typeof driver.isNew === 'boolean' &&
+        Array.isArray(driver.resources) &&
+        driver.resources.every(isDriverResource));
+};
+const hasValidMetadataEvidenceState = (state, evidence, billingGenerationId, inputManifestDigest, chartData, anomalies) => {
+    if (state === 'partial')
+        return isBillingPartialArtifactPublicationDecision(evidence, billingGenerationId, inputManifestDigest);
+    if (!isBillingCompletedArtifactPublicationDecision(evidence, billingGenerationId, inputManifestDigest))
+        return false;
+    if (state !== 'complete-empty')
+        return true;
+    if (!Array.isArray(anomalies))
+        return false;
+    const billingHistory = evidence.dependencies.find(dependency => dependency.name === 'billing-history');
+    if (!isRecord(chartData))
+        return false;
+    const dataWindow = chartData.dataWindow;
+    const views = chartData.views;
+    return (billingHistory?.emptyEvidence === 'complete-empty' &&
+        billingHistory.acceptedRowCount === 0 &&
+        isNonEmptyString(billingHistory.emptyProofRef) &&
+        isRecord(dataWindow) &&
+        dataWindow.pointCount === 0 &&
+        isRecord(views) &&
+        Object.values(views).every(view => view === undefined) &&
+        anomalies.length === 0);
+};
+const hasValidBillingCostAnalysisBusinessFields = (value) => {
+    if (!isPathSegment(value.subscriptionId) || !isPathSegment(value.billingGenerationId))
+        return false;
+    if (!isChartData(value.chartData) || !Array.isArray(value.anomalies) || !value.anomalies.every(isAnomaly))
+        return false;
+    if (!isNonEmptyString(value.currencyCode) || !isNonEmptyString(value.currencySymbol))
+        return false;
+    if (value.forecastMethod !== undefined && !isNonEmptyString(value.forecastMethod))
+        return false;
+    return [value.forecastMonthTotal, value.forecastRemaining, value.forecastPeriodEnd].every(isOptionalFiniteNumber);
+};
+const BILLING_PUBLIC_DATA_STATES = new Set(['current', 'stale', 'previous-verified']);
+const BILLING_PUBLIC_BUSINESS_FIELDS = new Set([
+    'schemaVersion',
+    'subscriptionId',
+    'dataState',
+    'chartData',
+    'anomalies',
+    'currencyCode',
+    'currencySymbol',
+    'forecastMethod',
+    'forecastMonthTotal',
+    'forecastRemaining',
+    'forecastPeriodEnd',
+]);
+const BILLING_PUBLIC_NO_ACTIVITY_FIELDS = new Set(['schemaVersion', 'subscriptionId', 'dataState']);
+const hasOnlyFields = (value, allowedFields) => Object.keys(value).every(field => allowedFields.has(field));
+const hasValidBillingCostAnalysisPublicBusinessFields = (value) => {
+    if (!isPathSegment(value.subscriptionId))
+        return false;
+    if (!isChartData(value.chartData) || !Array.isArray(value.anomalies) || !value.anomalies.every(isAnomaly))
+        return false;
+    if (!isNonEmptyString(value.currencyCode) || !isNonEmptyString(value.currencySymbol))
+        return false;
+    if (value.forecastMethod !== undefined && !isNonEmptyString(value.forecastMethod))
+        return false;
+    return [value.forecastMonthTotal, value.forecastRemaining, value.forecastPeriodEnd].every(isOptionalFiniteNumber);
+};
+/** Exact dependency-free validator for the customer-facing billing success contract. */
+export const isBillingCostAnalysisPublicResponse = (value) => {
+    if (!isRecord(value) || value.schemaVersion !== 1 || !isPathSegment(value.subscriptionId) || typeof value.dataState !== 'string') {
+        return false;
+    }
+    if (value.dataState === 'no-activity') {
+        return hasOnlyFields(value, BILLING_PUBLIC_NO_ACTIVITY_FIELDS);
+    }
+    return (BILLING_PUBLIC_DATA_STATES.has(value.dataState) &&
+        hasOnlyFields(value, BILLING_PUBLIC_BUSINESS_FIELDS) &&
+        !containsForbiddenBillingCostAnalysisControlData(value, 'business-v1') &&
+        hasValidBillingCostAnalysisPublicBusinessFields(value));
+};
+const isBillingCostAnalysisBusinessPayloadForBranch = (value, validationBranch) => !containsForbiddenBillingCostAnalysisControlData(value, validationBranch) &&
+    !LEGACY_FALLBACK_FORBIDDEN_OWN_FIELDS.some(field => hasOwn(value, field)) &&
+    hasValidBillingCostAnalysisBusinessFields(value);
+/** Dependency-free validator for the complete legacy V1 business payload. */
+export const isBillingCostAnalysisBusinessPayloadV1 = (value) => isRecord(value) && isBillingCostAnalysisBusinessPayloadForBranch(value, 'business-v1');
+/** Dependency-free validator for customer-readable V2 billing metadata. */
+export const isBillingCostAnalysisMetadataV2 = (value) => {
+    if (!isRecord(value) || containsForbiddenBillingCostAnalysisControlData(value, 'metadata-v2') || value.schemaVersion !== 2)
+        return false;
+    if (hasOwn(value, 'outputManifestDigest'))
+        return false;
+    if (!isPathSegment(value.subscriptionId) || !isPathSegment(value.billingGenerationId))
+        return false;
+    if (!isArtifactOwnershipBinding(value.ownership) || value.ownership.provider !== 'azure' || value.ownership.accountId !== value.subscriptionId)
+        return false;
+    if (!isArtifactRevisionVector(value.revision) || value.ownership.ownershipEpochRevision !== value.revision.ownershipEpochRevision) {
+        return false;
+    }
+    if (typeof value.artifactState !== 'string' || !BILLING_DOCUMENT_STATES.has(value.artifactState))
+        return false;
+    if (typeof value.inputManifestDigest !== 'string' || !SHA256_PATTERN.test(value.inputManifestDigest))
+        return false;
+    if (typeof value.outputBindingDigest !== 'string' || !SHA256_PATTERN.test(value.outputBindingDigest))
+        return false;
+    if (value.outputBindingDigest === value.inputManifestDigest ||
+        publicationDecisionReferencesDigest(value.artifactEvidence, value.outputBindingDigest)) {
+        return false;
+    }
+    if (!hasValidBillingCostAnalysisBusinessFields(value))
+        return false;
+    if (!hasValidMetadataEvidenceState(value.artifactState, value.artifactEvidence, value.billingGenerationId, value.inputManifestDigest, value.chartData, value.anomalies)) {
+        return false;
+    }
+    return true;
+};
+/** Dependency-free validator for an explicit legacy-transition fallback response. */
+export const isBillingCostAnalysisLegacyFallbackResponse = (value) => isRecord(value) &&
+    value.artifactState === 'fallback' &&
+    value.artifactSource === 'legacy-transition' &&
+    isBillingCostAnalysisBusinessPayloadForBranch(value, 'legacy-fallback');
+/** Dependency-free validator for an evidence-verified endpoint response. */
+export const isBillingCostAnalysisVerifiedReadResponse = (value) => isBillingCostAnalysisMetadataV2(value) && BILLING_VERIFIED_READ_STATES.has(value.artifactState);
+/** Dependency-free validator for the successful billing read-response union. */
+export const isBillingCostAnalysisReadResponse = (value) => isBillingCostAnalysisVerifiedReadResponse(value) || isBillingCostAnalysisLegacyFallbackResponse(value);

package/dist/esm/azure/budgets.js

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

package/dist/esm/azure/commitmentsPlanning.js

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

package/dist/esm/azure/common.js

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

package/dist/esm/azure/configs.js

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

package/dist/esm/azure/costComposition.js

@@ -0,0 +1,59 @@
+const CANONICAL_ESTIMATE_LENS_BY_LEGACY = {
+    'actual-only': 'billing-only',
+    'actual-plus-estimated': 'include-estimates',
+    'estimates-only': 'estimates-only',
+};
+const LEGACY_ESTIMATE_LENS_BY_CANONICAL = {
+    'billing-only': 'actual-only',
+    'include-estimates': 'actual-plus-estimated',
+    'estimates-only': 'estimates-only',
+};
+export const toCanonicalEstimateLensV1 = (value) => CANONICAL_ESTIMATE_LENS_BY_LEGACY[value];
+export const toLegacyEstimateLensV1 = (value) => LEGACY_ESTIMATE_LENS_BY_CANONICAL[value];
+const ESTIMATE_LENSES = new Set(['actual-only', 'actual-plus-estimated', 'estimates-only']);
+const SUPPORT_STATES = new Set(['supported', 'unsupported', 'unknown']);
+const BASIS_STATUSES = new Set(['actual-only', 'actual-plus-estimated', 'estimated-only', 'unavailable']);
+const ESTIMATE_CONFIDENCE_VALUES = new Set(['high', 'medium', 'low', 'unknown']);
+const MONEY_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+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 isPublicMoneyComponent = (value) => isRecord(value) &&
+    hasExactFields(value, ['amount', 'currencyCode']) &&
+    typeof value.amount === 'string' &&
+    MONEY_PATTERN.test(value.amount) &&
+    typeof value.currencyCode === 'string' &&
+    value.currencyCode.length > 0 &&
+    value.currencyCode === value.currencyCode.trim();
+const isPublicAvailability = (value) => {
+    if (!isRecord(value))
+        return false;
+    if (value.status === 'unavailable')
+        return hasExactFields(value, ['status']);
+    return value.status === 'available' && hasExactFields(value, ['status', 'component']) && isPublicMoneyComponent(value.component);
+};
+const isPublicComponentState = (value) => isRecord(value) &&
+    hasExactFields(value, ['support', 'availability']) &&
+    typeof value.support === 'string' &&
+    SUPPORT_STATES.has(value.support) &&
+    isPublicAvailability(value.availability);
+const isPublicBasis = (value, expectedBasis) => isRecord(value) &&
+    hasExactFields(value, ['basis', 'actual', 'estimated', 'combined', 'status'], ['estimateConfidence']) &&
+    value.basis === expectedBasis &&
+    isPublicComponentState(value.actual) &&
+    isPublicComponentState(value.estimated) &&
+    isPublicAvailability(value.combined) &&
+    typeof value.status === 'string' &&
+    BASIS_STATUSES.has(value.status) &&
+    (value.estimateConfidence === undefined ||
+        (typeof value.estimateConfidence === 'string' && ESTIMATE_CONFIDENCE_VALUES.has(value.estimateConfidence)));
+/** Exact dependency-free validator for the public cost-composition boundary. */
+export const isPublicCostComposition = (value) => isRecord(value) &&
+    hasExactFields(value, ['schemaVersion', 'selectedLens', 'billed', 'amortized']) &&
+    value.schemaVersion === 1 &&
+    typeof value.selectedLens === 'string' &&
+    ESTIMATE_LENSES.has(value.selectedLens) &&
+    isPublicBasis(value.billed, 'billed') &&
+    isPublicBasis(value.amortized, 'amortized');

package/dist/esm/azure/dataProtection.js

@@ -0,0 +1,5 @@
+export const DATA_PROTECTION_SCHEMA_VERSION = '2026-06-24';
+export const DATA_PROTECTION_SOURCE = 'Spotto.DataProtectionPosture';
+export const DATA_PROTECTION_PORTAL_FILE = 'data-protection.json.gz';
+export const DATA_PROTECTION_BACKUP_COST_DIAGNOSTICS_FILE = 'data-protection/backup-costs.json.gz';
+export const DATA_PROTECTION_BILLING_SOURCE_FILE = 'history/billing/cost-last-30-days.json';

package/dist/esm/azure/financialAnalytics.js

@@ -0,0 +1,2 @@
+export const FINANCIAL_ANALYTICS_INPUT_CONTRACT_VERSION_V1 = 'financial-analytics-input/v1';
+export const FINANCIAL_ANALYTICS_PROJECTION_CONTRACT_VERSION_V1 = 'financial-analytics-projection/v1';

package/dist/esm/azure/financialAnalyticsDelivery.js

@@ -0,0 +1,4 @@
+export const FINANCIAL_ANALYTICS_JOB_REQUEST_CONTRACT_VERSION_V1 = 'financial-analytics-job-request/v1';
+export const FINANCIAL_ANALYTICS_CURRENT_POINTER_CONTRACT_VERSION_V1 = 'financial-analytics-current-pointer/v1';
+export const FINANCIAL_ANALYTICS_INPUT_LOGICAL_NAME_V1 = 'financial-analytics-input.json.gz';
+export const FINANCIAL_ANALYTICS_PROJECTION_LOGICAL_NAME_V1 = 'financial-analytics-projection.json.gz';

package/dist/esm/azure/financialAnalyticsDeliveryValidation.js

@@ -0,0 +1,104 @@
+import { sha256Utf8 } from '../common/sha256.js';
+import { isFinancialAnalyticsInputSeriesV1, isFinancialAnalyticsProjectionV1 } from './financialAnalyticsValidation.js';
+import { FINANCIAL_ANALYTICS_CURRENT_POINTER_CONTRACT_VERSION_V1, FINANCIAL_ANALYTICS_JOB_REQUEST_CONTRACT_VERSION_V1, } from './financialAnalyticsDelivery.js';
+import { canonicalizeFinancialDataflowJsonV1, createFinancialDataflowCoordinateIdV1, hasFinancialDataflowExactFieldsV1, isFinancialDataflowHashV1, isFinancialDataflowIdentityV1, isFinancialDataflowIsoInstantV1, isFinancialDataflowRecordV1, isFinancialDataflowSortedUniqueStringsV1, } from './financialDataflowValidation.js';
+const RESULT_KINDS = new Set(['forecast', 'trend', 'anomaly']);
+const isJobRequestIdentity = (value) => isFinancialDataflowRecordV1(value) &&
+    hasFinancialDataflowExactFieldsV1(value, [
+        'schemaVersion',
+        'contractVersion',
+        'companyId',
+        'coordinateId',
+        'analyticsInputId',
+        'inputGenerationId',
+        'inputArtifactDigest',
+        'requestedResultKinds',
+    ]) &&
+    value.schemaVersion === 1 &&
+    value.contractVersion === FINANCIAL_ANALYTICS_JOB_REQUEST_CONTRACT_VERSION_V1 &&
+    isFinancialDataflowIdentityV1(value.companyId) &&
+    isFinancialDataflowHashV1(value.coordinateId) &&
+    isFinancialDataflowHashV1(value.analyticsInputId) &&
+    isFinancialDataflowIdentityV1(value.inputGenerationId) &&
+    isFinancialDataflowHashV1(value.inputArtifactDigest) &&
+    isFinancialDataflowSortedUniqueStringsV1(value.requestedResultKinds, RESULT_KINDS.size) &&
+    value.requestedResultKinds.length > 0 &&
+    value.requestedResultKinds.every(kind => RESULT_KINDS.has(kind));
+export const canonicalizeFinancialAnalyticsJobRequestIdentityV1 = (value) => {
+    if (!isJobRequestIdentity(value))
+        throw new TypeError('Invalid FinancialAnalyticsJobRequestIdentityPreimageV1.');
+    return canonicalizeFinancialDataflowJsonV1({ ...value, requestedResultKinds: [...value.requestedResultKinds].sort() });
+};
+export const createFinancialAnalyticsJobRequestIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialAnalyticsJobRequestIdentityV1(value))}`;
+export const isFinancialAnalyticsJobRequestV1 = (value) => {
+    if (!isFinancialDataflowRecordV1(value) ||
+        !hasFinancialDataflowExactFieldsV1(value, [
+            'schemaVersion',
+            'contractVersion',
+            'requestId',
+            'companyId',
+            'coordinateId',
+            'analyticsInputId',
+            'inputGenerationId',
+            'inputArtifactDigest',
+            'requestedResultKinds',
+            'requestedAt',
+        ]))
+        return false;
+    const { requestId, requestedAt, ...identity } = value;
+    return (isFinancialDataflowHashV1(requestId) &&
+        isFinancialDataflowIsoInstantV1(requestedAt) &&
+        isJobRequestIdentity(identity) &&
+        requestId === createFinancialAnalyticsJobRequestIdV1(identity));
+};
+/** Binds an identity-only queue request to already-verified immutable input bytes. */
+export const isFinancialAnalyticsJobRequestCompatibleV1 = (request, input, verifiedInputArtifactDigest) => isFinancialAnalyticsJobRequestV1(request) &&
+    isFinancialAnalyticsInputSeriesV1(input) &&
+    isFinancialDataflowHashV1(verifiedInputArtifactDigest) &&
+    request.companyId === input.coordinate.companyId &&
+    request.coordinateId === createFinancialDataflowCoordinateIdV1(input.coordinate) &&
+    request.analyticsInputId === input.analyticsInputId &&
+    request.inputGenerationId === input.producerGenerationId &&
+    request.inputArtifactDigest === verifiedInputArtifactDigest;
+const isCurrentPointerIdentity = (value) => isFinancialDataflowRecordV1(value) &&
+    hasFinancialDataflowExactFieldsV1(value, [
+        'schemaVersion',
+        'contractVersion',
+        'coordinateId',
+        'pointerRevision',
+        'outputGenerationId',
+        'analyticsProjectionId',
+        'projectionArtifactDigest',
+        'promotedAt',
+    ]) &&
+    value.schemaVersion === 1 &&
+    value.contractVersion === FINANCIAL_ANALYTICS_CURRENT_POINTER_CONTRACT_VERSION_V1 &&
+    isFinancialDataflowHashV1(value.coordinateId) &&
+    Number.isSafeInteger(value.pointerRevision) &&
+    Number(value.pointerRevision) > 0 &&
+    isFinancialDataflowIdentityV1(value.outputGenerationId) &&
+    isFinancialDataflowHashV1(value.analyticsProjectionId) &&
+    isFinancialDataflowHashV1(value.projectionArtifactDigest) &&
+    isFinancialDataflowIsoInstantV1(value.promotedAt);
+export const canonicalizeFinancialAnalyticsCurrentPointerIdentityV1 = (value) => {
+    if (!isCurrentPointerIdentity(value))
+        throw new TypeError('Invalid FinancialAnalyticsCurrentPointerIdentityPreimageV1.');
+    return canonicalizeFinancialDataflowJsonV1(value);
+};
+export const createFinancialAnalyticsCurrentPointerDigestV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialAnalyticsCurrentPointerIdentityV1(value))}`;
+export const isFinancialAnalyticsCurrentPointerV1 = (value) => {
+    if (!isFinancialDataflowRecordV1(value) || !Object.prototype.hasOwnProperty.call(value, 'pointerDigest'))
+        return false;
+    const { pointerDigest, ...identity } = value;
+    return (isFinancialDataflowHashV1(pointerDigest) &&
+        isCurrentPointerIdentity(identity) &&
+        pointerDigest === createFinancialAnalyticsCurrentPointerDigestV1(identity));
+};
+/** Binds a promoted pointer to already-verified immutable projection bytes. */
+export const isFinancialAnalyticsCurrentPointerCompatibleV1 = (pointer, projection, verifiedProjectionArtifactDigest) => isFinancialAnalyticsCurrentPointerV1(pointer) &&
+    isFinancialAnalyticsProjectionV1(projection) &&
+    isFinancialDataflowHashV1(verifiedProjectionArtifactDigest) &&
+    pointer.coordinateId === createFinancialDataflowCoordinateIdV1(projection.coordinate) &&
+    pointer.outputGenerationId === projection.outputGenerationId &&
+    pointer.analyticsProjectionId === projection.analyticsProjectionId &&
+    pointer.projectionArtifactDigest === verifiedProjectionArtifactDigest;