@spottoai/types-package 1.0.2-beta.43 → 1.0.2-beta.430

package/dist/esm/azure/recommendationWorkflow.js

@@ -0,0 +1,13 @@
+export const RecommendationWorkflowLanes = {
+    prioritized: 'prioritized',
+    todo: 'todo',
+    inProgress: 'in-progress',
+    blocked: 'blocked',
+    completed: 'completed',
+};
+export const RecommendationWorkflowSelectionModes = {
+    allAffected: 'all-affected',
+    selectedSubset: 'selected-subset',
+    subscriptionWide: 'subscription-wide',
+};
+export const RECOMMENDATION_WORKFLOW_REPAIR_PAGE_LIMIT = 250;

package/dist/esm/azure/recommendations.js

@@ -0,0 +1,10 @@
+export var RecommendationCategory;
+(function (RecommendationCategory) {
+    RecommendationCategory["Cost"] = "Cost";
+    RecommendationCategory["Performance"] = "Performance";
+    RecommendationCategory["Reliability"] = "Reliability";
+    RecommendationCategory["Security"] = "Security";
+    RecommendationCategory["Compliance"] = "Compliance";
+    RecommendationCategory["OperationalExcellence"] = "OperationalExcellence";
+    RecommendationCategory["OperationalExcellenceAlternative"] = "Operational Excellence";
+})(RecommendationCategory || (RecommendationCategory = {}));

package/dist/esm/azure/regulatoryCompliance.js

@@ -0,0 +1,6 @@
+export const REGULATORY_COMPLIANCE_REPORT_SCHEMA_VERSION = '2026-07-29.regulatory-compliance-v1';
+export const REGULATORY_COMPLIANCE_ASSIGNMENT_DETAIL_SCHEMA_VERSION = '2026-07-29.regulatory-compliance-assignment-v1';
+export const POLICY_EXEMPTION_COMMAND_SCHEMA_VERSION = '2026-07-29.policy-exemption-command-v1';
+export const REGULATORY_COMPLIANCE_PORTAL_FILE = 'regulatory-compliance.json.gz';
+export const REGULATORY_COMPLIANCE_ASSIGNMENT_DETAIL_DIRECTORY = 'regulatory-compliance/assignments';
+export const REGULATORY_COMPLIANCE_NOTE_TARGET_TYPES = ['assignment', 'control', 'policy'];

package/dist/esm/azure/relationships.js

@@ -0,0 +1,2 @@
+export const RELATIONSHIP_GRAPH_MANIFEST_SCHEMA_VERSION = 1;
+export const RELATIONSHIP_GRAPH_INDEX_SCHEMA_VERSION = 1;

package/dist/esm/azure/reportDailySpend.js

@@ -0,0 +1,2 @@
+/** Maximum span of the current month and two preceding complete calendar months. */
+export const REPORT_DAILY_SPEND_MAX_DAYS = 92;

package/dist/esm/azure/reportDailySpendValidation.js

@@ -0,0 +1,67 @@
+import { REPORT_DAILY_SPEND_MAX_DAYS } from './reportDailySpend.js';
+import { isCount, isFiniteNumber, isRecord } from './reportEvidenceValidationHelpers.js';
+import { hasReportSpendValue, isReportSpendAmounts } from './reportSpendValidation.js';
+import { isReportCalendarDate as isCalendarDate, isReportUtcTimestamp as isUtcTimestamp } from './reportSpendValidationHelpers.js';
+const DAY_MS = 86400000;
+const isCoverage = (value, covered, expected) => {
+    const status = covered === expected ? 'complete' : covered === 0 ? 'unavailable' : 'partial';
+    return isRecord(value) && isCount(value.coveredDayCount) && value.coveredDayCount === covered && value.status === status;
+};
+export const isReportDailySpend = (value) => {
+    if (!isRecord(value) ||
+        !isCalendarDate(value.startDate) ||
+        !isCalendarDate(value.endDate) ||
+        value.dateBasis !== 'billing-calendar' ||
+        typeof value.currency !== 'string' ||
+        !/^[A-Z]{3}$/.test(value.currency) ||
+        !isUtcTimestamp(value.generatedAt) ||
+        !['current', 'stale', 'unavailable'].includes(value.freshness) ||
+        !isRecord(value.coverage) ||
+        !Array.isArray(value.entries) ||
+        value.entries.length > REPORT_DAILY_SPEND_MAX_DAYS)
+        return false;
+    const expected = (Date.parse(value.endDate) - Date.parse(value.startDate)) / DAY_MS + 1;
+    if (expected < 1 || expected > REPORT_DAILY_SPEND_MAX_DAYS)
+        return false;
+    if ((value.sourceObservedAt !== undefined &&
+        (!isUtcTimestamp(value.sourceObservedAt) || Date.parse(value.sourceObservedAt) > Date.parse(value.generatedAt))) ||
+        (value.entries.length > 0 && (value.sourceObservedAt === undefined || value.freshness === 'unavailable')))
+        return false;
+    let previousDate = '';
+    let billedDays = 0;
+    let amortizedDays = 0;
+    for (const entry of value.entries) {
+        if (!isRecord(entry) ||
+            !isCalendarDate(entry.date) ||
+            entry.date <= previousDate ||
+            entry.date < value.startDate ||
+            entry.date > value.endDate ||
+            (entry.cost === undefined && entry.costAmortized === undefined && entry.financials === undefined) ||
+            (entry.cost !== undefined && !isFiniteNumber(entry.cost)) ||
+            (entry.costAmortized !== undefined && !isFiniteNumber(entry.costAmortized)))
+            return false;
+        if (entry.financials !== undefined) {
+            if (!isReportSpendAmounts(entry.financials, value.currency, value.generatedAt) || !hasReportSpendValue(entry.financials))
+                return false;
+            for (const [basis, field] of [
+                ['billed', 'cost'],
+                ['amortized', 'costAmortized'],
+            ]) {
+                const actual = entry.financials.composition[basis].actual.availability;
+                const complete = entry.financials.coverage[basis].actual === 'complete';
+                if (actual.status === 'available' && complete) {
+                    if (entry[field] !== Number(actual.component.amount))
+                        return false;
+                }
+                else if (entry[field] !== undefined)
+                    return false;
+            }
+        }
+        previousDate = entry.date;
+        if (entry.cost !== undefined)
+            billedDays++;
+        if (entry.costAmortized !== undefined)
+            amortizedDays++;
+    }
+    return isCoverage(value.coverage.billed, billedDays, expected) && isCoverage(value.coverage.amortized, amortizedDays, expected);
+};

package/dist/esm/azure/reportEvidence.js

@@ -0,0 +1,25 @@
+export const REPORT_EVIDENCE_LIMITS = {
+    detailRows: 50,
+    currentRecommendations: 90,
+    recommendationCatalogue: 2000,
+    complianceAssessments: 2000,
+    activityDays: 400,
+    activityMonths: 13,
+    recommendationResources: 2,
+    resourceCatalogue: 2000,
+    totalRecommendationResourceRows: 10000,
+    inventoryCatalogue: 2000,
+    healthCatalogue: 2000,
+    summaryDimensions: 25,
+    summaryRows: 20,
+    topRecommendationIds: 20,
+    topRecommendationIdsPerPillar: 5,
+    upcomingEvents: 20,
+    historyPeriods: 13,
+    historyRecommendations: 2000,
+    historyComparisonIdentities: 2000,
+    costChangePeriods: 13,
+    costChangeDrivers: 50,
+    costChangeReasons: 10,
+    tenantGlobalAdministrators: 50,
+};

package/dist/esm/azure/reportEvidenceCatalogueValidation.js

@@ -0,0 +1,103 @@
+import { REPORT_EVIDENCE_LIMITS } from './reportEvidence.js';
+import { isReportSavingsBasis } from './reportSpendValidation.js';
+import { hasValidReportSavingsMetadata } from './reportSavingsContributionValidation.js';
+import { isRecord, isString, isOptionalString, isOptionalFiniteNumber, isOptionalBoolean, isFiniteNumber, isCount, isBoundedRows, hasOptionalStrings, hasOptionalNumbers, } from './reportEvidenceValidationHelpers.js';
+const isCompactRecommendationResource = (value) => isRecord(value) &&
+    hasValidReportSavingsMetadata(value) &&
+    isString(value.id) &&
+    ['name', 'type', 'resourceGroup', 'location', 'currency', 'currencySymbol'].every(key => isOptionalString(value[key])) &&
+    ['spend', 'spendAmortized'].every(key => isOptionalFiniteNumber(value[key])) &&
+    (value.savingsBasis === undefined || isReportSavingsBasis(value.savingsBasis)) &&
+    (value.savings === undefined ||
+        (isRecord(value.savings) && isOptionalFiniteNumber(value.savings.minAmount) && isOptionalFiniteNumber(value.savings.maxAmount)));
+export const isCompactRecommendation = (value) => {
+    if (!isRecord(value) || !isRecord(value.recommendation) || !Array.isArray(value.resources))
+        return false;
+    if (!hasValidReportSavingsMetadata(value))
+        return false;
+    if (value.savingsBasis !== undefined && !isReportSavingsBasis(value.savingsBasis))
+        return false;
+    const recommendation = value.recommendation;
+    const assessment = recommendation.securityAssessmentSummary;
+    if (assessment !== undefined &&
+        (!isRecord(assessment) ||
+            !isCount(assessment.unhealthyCount) ||
+            !isCount(assessment.totalCount) ||
+            assessment.unhealthyCount > assessment.totalCount))
+        return false;
+    if (recommendation.securityImpactDetails !== undefined &&
+        (!isRecord(recommendation.securityImpactDetails) ||
+            !hasOptionalStrings(recommendation.securityImpactDetails, ['controlName', 'controlDisplayName'])))
+        return false;
+    if (!isString(recommendation.id) ||
+        !isString(recommendation.title) ||
+        recommendation.resolved === true ||
+        !isCount(value.resourcesCount) ||
+        !isCount(value.omittedResourceCount) ||
+        value.resources.length > REPORT_EVIDENCE_LIMITS.recommendationResources ||
+        !value.resources.every(isCompactRecommendationResource) ||
+        value.resourcesCount !== value.resources.length + value.omittedResourceCount) {
+        return false;
+    }
+    if (value.resourceCatalogue !== undefined &&
+        (!isBoundedRows(value.resourceCatalogue, REPORT_EVIDENCE_LIMITS.resourceCatalogue, isCompactRecommendationResource) ||
+            value.resourceCatalogue.totalCount !== value.resourcesCount))
+        return false;
+    if (!hasOptionalStrings(recommendation, [
+        'name',
+        'headline',
+        'plainSummary',
+        'bottomLine',
+        'description',
+        'remediation',
+        'impactReason',
+        'effortReason',
+        'potentialBenefits',
+        'considerations',
+        'technicalPlaybook',
+        'category',
+        'subCategory',
+        'impact',
+        'effort',
+        'severity',
+        'risk',
+        'priority',
+        'priorityLabel',
+        'priorityTier',
+        'manualPriority',
+        'costImpactUnit',
+    ]) ||
+        !hasOptionalNumbers(recommendation, [
+            'effortHours',
+            'costImpact',
+            'potentialMonthlySavings',
+            'confidencePercentage',
+            'adjustedScore',
+            'finalScore',
+            'normalizedScore',
+        ]) ||
+        !isOptionalBoolean(recommendation.resolved) ||
+        !isOptionalBoolean(recommendation.reportingTextTruncated) ||
+        !hasOptionalStrings(value, ['currency', 'currencySymbol'])) {
+        return false;
+    }
+    return (value.savings === undefined ||
+        (isRecord(value.savings) && isOptionalFiniteNumber(value.savings.minAmount) && isOptionalFiniteNumber(value.savings.maxAmount)));
+};
+export const isInventoryCatalogueResource = (value) => isRecord(value) &&
+    isCompactRecommendationResource(value) &&
+    isOptionalFiniteNumber(value.createdTime) &&
+    (value.tags === undefined ||
+        (isRecord(value.tags) &&
+            Object.keys(value.tags).length <= 100 &&
+            Object.entries(value.tags).every(([key, entry]) => key.length <= 512 && typeof entry === 'string' && entry.length <= 2048))) &&
+    (value.spottoTags === undefined ||
+        (isRecord(value.spottoTags) &&
+            Object.keys(value.spottoTags).length <= 100 &&
+            Object.entries(value.spottoTags).every(([key, entry]) => key.length <= 512 && isRecord(entry) && typeof entry.v === 'string' && entry.v.length <= 2048 && isFiniteNumber(entry.a)))) &&
+    (value.vmPricePerformance === undefined ||
+        (isRecord(value.vmPricePerformance) &&
+            isRecord(value.vmPricePerformance.current) &&
+            Array.isArray(value.vmPricePerformance.alternatives) &&
+            value.vmPricePerformance.alternatives.length <= 1 &&
+            value.vmPricePerformance.alternatives.every(isRecord)));