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

package/dist/esm/scheduler/resourceStrategyValidationShared.js

@@ -0,0 +1,261 @@
+import { RESOURCE_STRATEGY_CONTRACT_LIMITS } from './resourceStrategyContracts.js';
+const FORBIDDEN_AUTHORING_KEYS = new Set([
+    '__proto__',
+    'prototype',
+    'constructor',
+    'actionId',
+    'actionRef',
+    'actionDefinitionId',
+    'actionDefinitionRef',
+    'workflowRef',
+    'operation',
+    'providerOperation',
+    'compiledOperation',
+    'httpMethod',
+    'endpoint',
+    'apiVersion',
+    'requestTemplate',
+    'permissions',
+    'permissionActions',
+    'permissionSetRef',
+    'permissionSetRefs',
+    'baseline',
+    'baselineRef',
+    'selectorRef',
+    'restoreBaseline',
+    'compiledDueRow',
+]);
+const INHERITED_FORBIDDEN_AUTHORING_KEYS = [...FORBIDDEN_AUTHORING_KEYS].filter(key => key !== '__proto__' && key !== 'prototype' && key !== 'constructor');
+export function isRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    try {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null)
+            return false;
+        return Reflect.ownKeys(value).every(key => {
+            if (typeof key !== 'string')
+                return false;
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            return descriptor !== undefined && descriptor.enumerable && 'value' in descriptor;
+        });
+    }
+    catch {
+        return false;
+    }
+}
+export function hasOnlyKeys(value, allowed) {
+    try {
+        const allowedSet = new Set(allowed);
+        return (Object.keys(value).every(key => allowedSet.has(key)) &&
+            allowed.every(key => !Reflect.has(value, key) || Object.prototype.hasOwnProperty.call(value, key)));
+    }
+    catch {
+        return false;
+    }
+}
+export function isBoundedString(value, maximum = RESOURCE_STRATEGY_CONTRACT_LIMITS.textLength) {
+    return typeof value === 'string' && value.length > 0 && value.length <= maximum;
+}
+export function isOptionalBoundedString(value, maximum = RESOURCE_STRATEGY_CONTRACT_LIMITS.textLength) {
+    return value === undefined || isBoundedString(value, maximum);
+}
+export function isPositiveInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+}
+export function isNonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+export function isIsoTimestamp(value) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value))
+        return false;
+    const instant = new Date(value);
+    if (!Number.isFinite(instant.getTime()))
+        return false;
+    const canonical = instant.toISOString();
+    return value.includes('.') ? canonical === value : canonical.replace('.000Z', 'Z') === value;
+}
+export function isDate(value) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const date = new Date(`${value}T00:00:00.000Z`);
+    return Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+export function isTime(value) {
+    return typeof value === 'string' && /^(?:[01]\d|2[0-3]):[0-5]\d$/.test(value);
+}
+export function isCurrency(value) {
+    return typeof value === 'string' && /^[A-Z]{3}$/.test(value);
+}
+export function isNonNegativeDecimal(value) {
+    return typeof value === 'string' && /^\d{1,15}(?:\.\d{1,8})?$/.test(value);
+}
+export function isIanaTimezone(value) {
+    if (!isBoundedString(value, 100))
+        return false;
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: value }).format(0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function jsonStringByteLengthWithin(value, maximum) {
+    let bytes = 2;
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit === 0x22 ||
+            codeUnit === 0x5c ||
+            codeUnit === 0x08 ||
+            codeUnit === 0x09 ||
+            codeUnit === 0x0a ||
+            codeUnit === 0x0c ||
+            codeUnit === 0x0d) {
+            bytes += 2;
+        }
+        else if (codeUnit <= 0x1f ||
+            (codeUnit >= 0xd800 &&
+                codeUnit <= 0xdfff &&
+                !(codeUnit <= 0xdbff && index + 1 < value.length && value.charCodeAt(index + 1) >= 0xdc00 && value.charCodeAt(index + 1) <= 0xdfff))) {
+            bytes += 6;
+        }
+        else if (codeUnit <= 0x7f) {
+            bytes += 1;
+        }
+        else if (codeUnit <= 0x7ff) {
+            bytes += 2;
+        }
+        else if (codeUnit <= 0xdbff) {
+            bytes += 4;
+            index += 1;
+        }
+        else {
+            bytes += 3;
+        }
+        if (bytes > maximum)
+            return null;
+    }
+    return bytes;
+}
+export function isWithinJsonByteLimit(value, maximum) {
+    if (!Number.isSafeInteger(maximum) || maximum < 0)
+        return false;
+    const stack = [value];
+    let bytes = 0;
+    let nodes = 0;
+    try {
+        while (stack.length > 0) {
+            nodes += 1;
+            if (nodes > 10000)
+                return false;
+            const current = stack.pop();
+            if (current === null) {
+                bytes += 4;
+            }
+            else if (typeof current === 'string') {
+                const stringBytes = jsonStringByteLengthWithin(current, maximum - bytes);
+                if (stringBytes === null)
+                    return false;
+                bytes += stringBytes;
+            }
+            else if (typeof current === 'number') {
+                if (!Number.isFinite(current))
+                    return false;
+                bytes += String(Object.is(current, -0) ? 0 : current).length;
+            }
+            else if (typeof current === 'boolean') {
+                bytes += current ? 4 : 5;
+            }
+            else if (Array.isArray(current)) {
+                if (Object.getPrototypeOf(current) !== Array.prototype)
+                    return false;
+                bytes += 2 + Math.max(0, current.length - 1);
+                if (bytes > maximum)
+                    return false;
+                const ownKeys = Reflect.ownKeys(current);
+                if (ownKeys.length !== current.length + 1 || !ownKeys.includes('length'))
+                    return false;
+                for (let index = 0; index < current.length; index += 1) {
+                    const descriptor = Object.getOwnPropertyDescriptor(current, String(index));
+                    if (descriptor === undefined || !descriptor.enumerable || !('value' in descriptor))
+                        return false;
+                    stack.push(descriptor.value);
+                }
+            }
+            else if (isRecord(current)) {
+                const keys = Object.keys(current);
+                bytes += 2 + Math.max(0, keys.length - 1);
+                if (bytes > maximum)
+                    return false;
+                for (const key of keys) {
+                    const keyBytes = jsonStringByteLengthWithin(key, maximum - bytes);
+                    if (keyBytes === null)
+                        return false;
+                    bytes += keyBytes + 1;
+                    if (bytes > maximum)
+                        return false;
+                    const descriptor = Object.getOwnPropertyDescriptor(current, key);
+                    if (descriptor === undefined || !('value' in descriptor))
+                        return false;
+                    stack.push(descriptor.value);
+                }
+            }
+            else {
+                return false;
+            }
+            if (bytes > maximum)
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isBoundedStringArray(value, maximum = RESOURCE_STRATEGY_CONTRACT_LIMITS.metadataItems) {
+    return Array.isArray(value) && value.length <= maximum && value.every(item => isBoundedString(item, 2000));
+}
+export function containsForbiddenKey(value, depth = 0) {
+    try {
+        if (depth > 8)
+            return true;
+        if (value !== null && typeof value === 'object') {
+            if (INHERITED_FORBIDDEN_AUTHORING_KEYS.some(key => Reflect.has(value, key) && !Object.prototype.hasOwnProperty.call(value, key))) {
+                return true;
+            }
+        }
+        if (Array.isArray(value))
+            return value.some(item => containsForbiddenKey(item, depth + 1));
+        if (!isRecord(value))
+            return false;
+        return Object.keys(value).some(key => FORBIDDEN_AUTHORING_KEYS.has(key) || containsForbiddenKey(value[key], depth + 1));
+    }
+    catch {
+        return true;
+    }
+}
+function isBoundedJsonValue(value, depth = 0) {
+    if (depth > 8)
+        return false;
+    if (value === null || typeof value === 'boolean' || typeof value === 'string')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.length <= 128 && value.every(item => isBoundedJsonValue(item, depth + 1));
+    if (!isRecord(value) || Object.keys(value).length > 128)
+        return false;
+    return Object.entries(value).every(([key, item]) => !FORBIDDEN_AUTHORING_KEYS.has(key) && isBoundedJsonValue(item, depth + 1));
+}
+export function isBoundedParameters(value) {
+    if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.parameterBytes))
+        return false;
+    return isRecord(value) && isBoundedJsonValue(value) && !containsForbiddenKey(value);
+}
+export function isCapabilityRef(value) {
+    return (isRecord(value) &&
+        hasOnlyKeys(value, ['capabilityId', 'capabilityVersion']) &&
+        isBoundedString(value.capabilityId, 200) &&
+        isPositiveInteger(value.capabilityVersion));
+}

package/dist/esm/scheduler/schedulerContracts.js

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

package/dist/esm/scheduler/schedulerValidation.js

@@ -0,0 +1,372 @@
+import { RESOURCE_STRATEGY_CONTRACT_LIMITS } from './resourceStrategyContracts.js';
+import { isResourceStrategyScheduleCommand, isResourceStrategyWeeklyScheduleProjection, isResourceStrategyWeeklyScheduleWriteRequest, } from './resourceStrategyScheduleValidation.js';
+import { isResourceSchedulePermissionManifestConsent } from './resourceStrategyPermissionValidation.js';
+import { isResourceSchedulingCapabilityProjection, isResourceSchedulingReadinessProjection } from './resourceStrategyCapabilityValidation.js';
+import { isResourceSchedulePreviewRequest, isResourceSchedulePreviewResponse } from './resourceStrategyFinancialValidation.js';
+import { hasOnlyKeys, isBoundedParameters, isBoundedString, isIanaTimezone, isIsoTimestamp, isOptionalBoundedString, isPositiveInteger, isRecord, isWithinJsonByteLimit, } from './resourceStrategyValidationShared.js';
+import { isScheduledResourceTransitionV1 } from './resourceStrategyScheduleValidation.js';
+const LOCAL_DATE_TIME = /^\d{4}-\d{2}-\d{2}T(?:[01]\d|2[0-3]):[0-5]\d$/u;
+function isLocalDateTime(value) {
+    if (typeof value !== 'string' || !LOCAL_DATE_TIME.test(value))
+        return false;
+    const parsed = new Date(`${value}:00.000Z`);
+    return Number.isFinite(parsed.getTime()) && parsed.toISOString().slice(0, 16) === value;
+}
+function isFiveFieldCronExpression(value) {
+    return isBoundedString(value, 500) && value.trim() === value && value.split(/\s+/u).length === 5;
+}
+function isRecommendationActionScheduleTarget(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.selectorType === 'single-resource') {
+        return hasOnlyKeys(value, ['selectorType', 'resourceId']) && isBoundedString(value.resourceId, 2000);
+    }
+    if (value.selectorType === 'selected-resources') {
+        return (hasOnlyKeys(value, ['selectorType', 'resourceIds']) &&
+            Array.isArray(value.resourceIds) &&
+            value.resourceIds.length > 0 &&
+            value.resourceIds.length <= 100 &&
+            new Set(value.resourceIds).size === value.resourceIds.length &&
+            value.resourceIds.every(resourceId => isBoundedString(resourceId, 2000)));
+    }
+    return value.selectorType === 'provider-scope' && hasOnlyKeys(value, ['selectorType']);
+}
+export function isRecommendationActionScheduleWriteRequest(value) {
+    try {
+        if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) || !isRecord(value))
+            return false;
+        if (!hasOnlyKeys(value, [
+            'definitionType',
+            'name',
+            'timezone',
+            'trigger',
+            'providerScopeId',
+            'cloudAccountId',
+            'recommendationId',
+            'operation',
+            'target',
+            'initialMode',
+            'notes',
+            'configuration',
+        ]) ||
+            value.definitionType !== 'recommendation-action' ||
+            !isBoundedString(value.name, 500) ||
+            !isIanaTimezone(value.timezone) ||
+            !isBoundedString(value.providerScopeId, 500) ||
+            !isOptionalBoundedString(value.cloudAccountId, 500) ||
+            !isBoundedString(value.recommendationId, 500) ||
+            value.operation !== 'implement' ||
+            !isRecommendationActionScheduleTarget(value.target) ||
+            (value.initialMode !== 'active' && value.initialMode !== 'paused') ||
+            !isOptionalBoundedString(value.notes, 4000) ||
+            (value.configuration !== undefined && !isBoundedParameters(value.configuration)) ||
+            !isRecord(value.trigger)) {
+            return false;
+        }
+        if (value.trigger.triggerType === 'once') {
+            return hasOnlyKeys(value.trigger, ['triggerType', 'localDateTime']) && isLocalDateTime(value.trigger.localDateTime);
+        }
+        return (value.trigger.triggerType === 'recurring' &&
+            hasOnlyKeys(value.trigger, ['triggerType', 'cronExpression']) &&
+            isFiveFieldCronExpression(value.trigger.cronExpression));
+    }
+    catch {
+        return false;
+    }
+}
+export function isScheduleWriteRequest(value) {
+    return isResourceStrategyWeeklyScheduleWriteRequest(value) || isRecommendationActionScheduleWriteRequest(value);
+}
+export function isScheduleMutationRequest(value) {
+    return (isRecord(value) &&
+        hasOnlyKeys(value, ['definition', 'permissionConsent']) &&
+        isScheduleWriteRequest(value.definition) &&
+        (value.permissionConsent === undefined || isResourceSchedulePermissionManifestConsent(value.permissionConsent)));
+}
+export function isRecommendationActionScheduleCommand(value) {
+    return (isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) &&
+        isRecord(value) &&
+        hasOnlyKeys(value, ['command', 'idempotencyKey']) &&
+        (value.command === 'pause' || value.command === 'resume') &&
+        isBoundedString(value.idempotencyKey, 200));
+}
+export function isScheduleCommand(value) {
+    return isRecommendationActionScheduleCommand(value) || isResourceStrategyScheduleCommand(value);
+}
+export function isRecommendationActionScheduleProjection(value) {
+    try {
+        if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) || !isRecord(value))
+            return false;
+        return (hasOnlyKeys(value, [
+            'scheduleId',
+            'definitionRevision',
+            'controlGeneration',
+            'etag',
+            'status',
+            'definition',
+            'nextOccurrenceAtUtc',
+            'lastOccurrenceAtUtc',
+            'lastOccurrenceOutcome',
+            'createdAtUtc',
+            'createdBy',
+            'updatedAtUtc',
+            'updatedBy',
+        ]) &&
+            isBoundedString(value.scheduleId, 500) &&
+            isPositiveInteger(value.definitionRevision) &&
+            isPositiveInteger(value.controlGeneration) &&
+            isBoundedString(value.etag, 2000) &&
+            ['active', 'paused', 'completed'].includes(String(value.status)) &&
+            isRecommendationActionScheduleWriteRequest(value.definition) &&
+            (value.nextOccurrenceAtUtc === undefined || isIsoTimestamp(value.nextOccurrenceAtUtc)) &&
+            (value.lastOccurrenceAtUtc === undefined || isIsoTimestamp(value.lastOccurrenceAtUtc)) &&
+            (value.lastOccurrenceOutcome === undefined || ['succeeded', 'failed', 'skipped'].includes(String(value.lastOccurrenceOutcome))) &&
+            (value.lastOccurrenceAtUtc === undefined) === (value.lastOccurrenceOutcome === undefined) &&
+            isIsoTimestamp(value.createdAtUtc) &&
+            isBoundedString(value.createdBy, 500) &&
+            isIsoTimestamp(value.updatedAtUtc) &&
+            isBoundedString(value.updatedBy, 500));
+    }
+    catch {
+        return false;
+    }
+}
+export function isScheduleProjection(value) {
+    return isResourceStrategyWeeklyScheduleProjection(value) || isRecommendationActionScheduleProjection(value);
+}
+export function isScheduleListResponse(value) {
+    return (isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) &&
+        isRecord(value) &&
+        hasOnlyKeys(value, ['results', 'continuation']) &&
+        Array.isArray(value.results) &&
+        value.results.length <= RESOURCE_STRATEGY_CONTRACT_LIMITS.listResults &&
+        value.results.every(isScheduleProjection) &&
+        (value.continuation === undefined ||
+            (isRecord(value.continuation) && hasOnlyKeys(value.continuation, ['cursor']) && isBoundedString(value.continuation.cursor, 2000))));
+}
+export function isScheduledRecommendationActionV1(value) {
+    try {
+        return (isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) &&
+            isRecord(value) &&
+            hasOnlyKeys(value, [
+                'schemaVersion',
+                'definitionType',
+                'companyId',
+                'providerScopeId',
+                'cloudAccountId',
+                'scheduleId',
+                'definitionRevision',
+                'controlGeneration',
+                'occurrenceKey',
+                'scheduleRunId',
+                'dueAtUtc',
+                'recommendationId',
+                'operation',
+                'target',
+                'configuration',
+                'correlationId',
+            ]) &&
+            value.schemaVersion === 1 &&
+            value.definitionType === 'recommendation-action' &&
+            isBoundedString(value.companyId, 500) &&
+            isBoundedString(value.providerScopeId, 500) &&
+            isOptionalBoundedString(value.cloudAccountId, 500) &&
+            isBoundedString(value.scheduleId, 500) &&
+            isPositiveInteger(value.definitionRevision) &&
+            isPositiveInteger(value.controlGeneration) &&
+            isBoundedString(value.occurrenceKey, 2000) &&
+            isBoundedString(value.scheduleRunId, 500) &&
+            isIsoTimestamp(value.dueAtUtc) &&
+            isBoundedString(value.recommendationId, 500) &&
+            value.operation === 'implement' &&
+            isRecommendationActionScheduleTarget(value.target) &&
+            isBoundedParameters(value.configuration) &&
+            isBoundedString(value.correlationId, 500));
+    }
+    catch {
+        return false;
+    }
+}
+export function isScheduledOccurrenceV1(value) {
+    return isScheduledResourceTransitionV1(value) || isScheduledRecommendationActionV1(value);
+}
+const schedulerOperationTypes = new Set([
+    'refresh-capabilities',
+    'create-schedule',
+    'update-schedule',
+    'delete-schedule',
+    'apply-schedule-command',
+    'refresh-readiness',
+    'preview-resource-schedule',
+]);
+function isEmptyOrBoundedString(value, maxLength) {
+    return typeof value === 'string' && value.length <= maxLength;
+}
+function isSchedulerControlCommandV1(value) {
+    if (!isRecord(value) || typeof value.commandType !== 'string' || !schedulerOperationTypes.has(value.commandType)) {
+        return false;
+    }
+    switch (value.commandType) {
+        case 'refresh-capabilities':
+            return hasOnlyKeys(value, ['commandType']);
+        case 'create-schedule':
+            return (hasOnlyKeys(value, ['commandType', 'definition', 'permissionConsent', 'idempotencyKey']) &&
+                isScheduleWriteRequest(value.definition) &&
+                (value.permissionConsent === undefined || isResourceSchedulePermissionManifestConsent(value.permissionConsent)) &&
+                isBoundedString(value.idempotencyKey, 200));
+        case 'update-schedule':
+            return (hasOnlyKeys(value, ['commandType', 'scheduleId', 'definition', 'permissionConsent', 'expectedEtag', 'idempotencyKey']) &&
+                isBoundedString(value.scheduleId, 500) &&
+                isScheduleWriteRequest(value.definition) &&
+                (value.permissionConsent === undefined || isResourceSchedulePermissionManifestConsent(value.permissionConsent)) &&
+                isBoundedString(value.expectedEtag, 2000) &&
+                isBoundedString(value.idempotencyKey, 200));
+        case 'delete-schedule':
+            return (hasOnlyKeys(value, ['commandType', 'scheduleId', 'expectedEtag', 'idempotencyKey']) &&
+                isBoundedString(value.scheduleId, 500) &&
+                isBoundedString(value.expectedEtag, 2000) &&
+                isBoundedString(value.idempotencyKey, 200));
+        case 'apply-schedule-command':
+            return (hasOnlyKeys(value, ['commandType', 'scheduleId', 'expectedEtag', 'scheduleCommand']) &&
+                isBoundedString(value.scheduleId, 500) &&
+                isBoundedString(value.expectedEtag, 2000) &&
+                isScheduleCommand(value.scheduleCommand));
+        case 'refresh-readiness':
+            return (hasOnlyKeys(value, ['commandType', 'cloudAccountId', 'providerScopeId', 'resourceId', 'capability']) &&
+                isBoundedString(value.cloudAccountId, 500) &&
+                isBoundedString(value.providerScopeId, 500) &&
+                isBoundedString(value.resourceId, 2000) &&
+                isRecord(value.capability) &&
+                hasOnlyKeys(value.capability, ['capabilityId', 'capabilityVersion']) &&
+                isBoundedString(value.capability.capabilityId, 200) &&
+                isPositiveInteger(value.capability.capabilityVersion));
+        case 'preview-resource-schedule':
+            return hasOnlyKeys(value, ['commandType', 'request']) && isResourceSchedulePreviewRequest(value.request);
+    }
+    return false;
+}
+export function isSchedulerControlRequestMessageV1(value) {
+    try {
+        return (isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) &&
+            isRecord(value) &&
+            hasOnlyKeys(value, [
+                'schemaVersion',
+                'entity',
+                'action',
+                'companyId',
+                'cloudAccountId',
+                'tenantId',
+                'clientId',
+                'operationId',
+                'requestedAtUtc',
+                'actorId',
+                'correlationId',
+                'command',
+            ]) &&
+            value.schemaVersion === 1 &&
+            value.entity === 'scheduler' &&
+            value.action === 'control' &&
+            isBoundedString(value.companyId, 500) &&
+            isEmptyOrBoundedString(value.cloudAccountId, 500) &&
+            isEmptyOrBoundedString(value.tenantId, 500) &&
+            isEmptyOrBoundedString(value.clientId, 500) &&
+            isBoundedString(value.operationId, 200) &&
+            isIsoTimestamp(value.requestedAtUtc) &&
+            isBoundedString(value.actorId, 500) &&
+            isBoundedString(value.correlationId, 500) &&
+            isSchedulerControlCommandV1(value.command));
+    }
+    catch {
+        return false;
+    }
+}
+export function isSchedulerOperationAcceptedResponse(value) {
+    return (isRecord(value) &&
+        hasOnlyKeys(value, ['schemaVersion', 'operationId', 'status', 'submittedAtUtc']) &&
+        value.schemaVersion === 1 &&
+        isBoundedString(value.operationId, 200) &&
+        value.status === 'accepted' &&
+        isIsoTimestamp(value.submittedAtUtc));
+}
+function isSchedulerOperationResult(value, operationType) {
+    if (!isRecord(value) || typeof value.resultType !== 'string')
+        return false;
+    if (value.resultType === 'capabilities') {
+        return (operationType === 'refresh-capabilities' &&
+            hasOnlyKeys(value, ['resultType', 'capabilities']) &&
+            Array.isArray(value.capabilities) &&
+            value.capabilities.every(isResourceSchedulingCapabilityProjection));
+    }
+    if (value.resultType === 'schedule') {
+        return (['create-schedule', 'update-schedule', 'apply-schedule-command'].includes(operationType) &&
+            hasOnlyKeys(value, ['resultType', 'schedule']) &&
+            isScheduleProjection(value.schedule));
+    }
+    if (value.resultType === 'deleted') {
+        return operationType === 'delete-schedule' && hasOnlyKeys(value, ['resultType']);
+    }
+    if (value.resultType === 'readiness') {
+        return (operationType === 'refresh-readiness' &&
+            hasOnlyKeys(value, ['resultType', 'readiness']) &&
+            isResourceSchedulingReadinessProjection(value.readiness));
+    }
+    return (value.resultType === 'preview' &&
+        operationType === 'preview-resource-schedule' &&
+        hasOnlyKeys(value, ['resultType', 'preview']) &&
+        isResourceSchedulePreviewResponse(value.preview));
+}
+export function isSchedulerOperationProjection(value) {
+    try {
+        if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) ||
+            !isRecord(value) ||
+            value.schemaVersion !== 1 ||
+            !isBoundedString(value.companyId, 500) ||
+            !isBoundedString(value.operationId, 200) ||
+            typeof value.operationType !== 'string' ||
+            !schedulerOperationTypes.has(value.operationType) ||
+            !isIsoTimestamp(value.submittedAtUtc) ||
+            !isIsoTimestamp(value.updatedAtUtc)) {
+            return false;
+        }
+        const operationType = value.operationType;
+        if (value.status === 'pending') {
+            return hasOnlyKeys(value, ['schemaVersion', 'companyId', 'operationId', 'operationType', 'status', 'submittedAtUtc', 'updatedAtUtc']);
+        }
+        if (value.status === 'succeeded') {
+            return (hasOnlyKeys(value, [
+                'schemaVersion',
+                'companyId',
+                'operationId',
+                'operationType',
+                'status',
+                'submittedAtUtc',
+                'updatedAtUtc',
+                'completedAtUtc',
+                'result',
+            ]) &&
+                isIsoTimestamp(value.completedAtUtc) &&
+                isSchedulerOperationResult(value.result, operationType));
+        }
+        return (value.status === 'failed' &&
+            hasOnlyKeys(value, [
+                'schemaVersion',
+                'companyId',
+                'operationId',
+                'operationType',
+                'status',
+                'submittedAtUtc',
+                'updatedAtUtc',
+                'completedAtUtc',
+                'error',
+            ]) &&
+            isIsoTimestamp(value.completedAtUtc) &&
+            isRecord(value.error) &&
+            hasOnlyKeys(value.error, ['code', 'message', 'retryable']) &&
+            isBoundedString(value.error.code, 100) &&
+            isBoundedString(value.error.message, 500) &&
+            typeof value.error.retryable === 'boolean');
+    }
+    catch {
+        return false;
+    }
+}