@spottoai/types-package 1.0.2-beta.42 → 1.0.2-beta.421

package/dist/esm/scheduler/resourceStrategyPermissionValidation.js

@@ -0,0 +1,190 @@
+import { RESOURCE_STRATEGY_CONTRACT_LIMITS, } from './resourceStrategyContracts.js';
+import { hasOnlyKeys, isBoundedString, isBoundedStringArray, isCapabilityRef, isIsoTimestamp, isRecord, isWithinJsonByteLimit, } from './resourceStrategyValidationShared.js';
+export function isResourceSchedulePermissionManifestProjection(value) {
+    if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) ||
+        !isRecord(value) ||
+        !hasOnlyKeys(value, [
+            'schemaVersion',
+            'provider',
+            'version',
+            'contentHash',
+            'capabilityVersions',
+            'orderedGrantGroupHashes',
+            'grantGroups',
+            'generatedAtUtc',
+            'evidenceObservedAtUtc',
+            'expiresAtUtc',
+            'reviewStatus',
+            'change',
+        ]) ||
+        value.schemaVersion !== 1 ||
+        !isBoundedString(value.provider, 100) ||
+        !isBoundedString(value.version, 200) ||
+        !isBoundedString(value.contentHash, 200) ||
+        !Array.isArray(value.capabilityVersions) ||
+        value.capabilityVersions.length === 0 ||
+        value.capabilityVersions.length > RESOURCE_STRATEGY_CONTRACT_LIMITS.metadataItems ||
+        !value.capabilityVersions.every(isCapabilityRef) ||
+        !Array.isArray(value.grantGroups) ||
+        value.grantGroups.length === 0 ||
+        value.grantGroups.length > RESOURCE_STRATEGY_CONTRACT_LIMITS.grantGroups ||
+        !Array.isArray(value.orderedGrantGroupHashes) ||
+        value.orderedGrantGroupHashes.length !== value.grantGroups.length ||
+        !isIsoTimestamp(value.generatedAtUtc) ||
+        !isIsoTimestamp(value.evidenceObservedAtUtc) ||
+        !(value.expiresAtUtc === null || isIsoTimestamp(value.expiresAtUtc)) ||
+        !['current', 'review-required', 'expired'].includes(String(value.reviewStatus)) ||
+        !isRecord(value.change) ||
+        !hasOnlyKeys(value.change, ['status', 'addedOperations', 'removedOperations']) ||
+        !['new', 'unchanged', 'expanding', 'narrowing', 'missing'].includes(String(value.change.status)) ||
+        !isPermissionChangeOperations(value.change.addedOperations) ||
+        !isPermissionChangeOperations(value.change.removedOperations) ||
+        Date.parse(value.evidenceObservedAtUtc) > Date.parse(value.generatedAtUtc) ||
+        (typeof value.expiresAtUtc === 'string' && Date.parse(value.expiresAtUtc) < Date.parse(value.generatedAtUtc)) ||
+        new Set(value.capabilityVersions.map(item => `${item.capabilityId}:${item.capabilityVersion}`)).size !== value.capabilityVersions.length) {
+        return false;
+    }
+    const change = value.change;
+    const addedKeys = new Set(change.addedOperations.map(permissionChangeOperationKey));
+    const removedKeys = new Set(change.removedOperations.map(permissionChangeOperationKey));
+    if (addedKeys.size !== change.addedOperations.length ||
+        removedKeys.size !== change.removedOperations.length ||
+        [...addedKeys].some(key => removedKeys.has(key))) {
+        return false;
+    }
+    if ((value.change.status === 'unchanged' && (change.addedOperations.length > 0 || change.removedOperations.length > 0)) ||
+        ((value.change.status === 'new' || value.change.status === 'missing') &&
+            (change.addedOperations.length === 0 || change.removedOperations.length > 0)) ||
+        (value.change.status === 'expanding' && change.addedOperations.length === 0) ||
+        (value.change.status === 'narrowing' && (change.addedOperations.length > 0 || change.removedOperations.length === 0))) {
+        return false;
+    }
+    const grantGroups = value.grantGroups;
+    const seenGroupHashes = new Set();
+    const validGrantGroups = grantGroups.every(group => {
+        if (!isRecord(group) ||
+            !hasOnlyKeys(group, [
+                'groupHash',
+                'provider',
+                'providerScopeId',
+                'exactAssignmentScope',
+                'operationSetHash',
+                'principalRef',
+                'roleDefinitionRef',
+                'roleName',
+                'roleDefinitionScope',
+                'roleAssignmentRef',
+                'actions',
+                'dataActions',
+                'disclosureKeys',
+            ]) ||
+            !isBoundedString(group.groupHash, 200) ||
+            group.provider !== value.provider ||
+            !isBoundedString(group.providerScopeId, 300) ||
+            !isBoundedString(group.exactAssignmentScope, 2000) ||
+            !isBoundedString(group.operationSetHash, 200) ||
+            !isBoundedString(group.principalRef, 200) ||
+            !isBoundedString(group.roleDefinitionRef, 200) ||
+            !isBoundedString(group.roleName, 500) ||
+            !isBoundedString(group.roleDefinitionScope, 2000) ||
+            !isBoundedString(group.roleAssignmentRef, 200) ||
+            !isPermissionOperations(group.actions) ||
+            !isPermissionOperations(group.dataActions) ||
+            group.actions.length + group.dataActions.length === 0 ||
+            (group.disclosureKeys !== undefined && !isBoundedStringArray(group.disclosureKeys)) ||
+            seenGroupHashes.has(group.groupHash)) {
+            return false;
+        }
+        const actions = group.actions;
+        const dataActions = group.dataActions;
+        if (actions.some(action => dataActions.some(dataAction => dataAction.operation.toLowerCase() === action.operation.toLowerCase()))) {
+            return false;
+        }
+        seenGroupHashes.add(group.groupHash);
+        return true;
+    });
+    if (!validGrantGroups ||
+        !value.orderedGrantGroupHashes.every((hash, index) => isBoundedString(hash, 200) && isRecord(grantGroups[index]) && hash === grantGroups[index].groupHash)) {
+        return false;
+    }
+    const currentOperationKeys = new Set();
+    for (const group of grantGroups) {
+        if (!isRecord(group))
+            return false;
+        for (const operation of group.actions) {
+            currentOperationKeys.add(permissionChangeOperationKey({
+                groupHash: String(group.groupHash),
+                providerScopeId: String(group.providerScopeId),
+                exactAssignmentScope: String(group.exactAssignmentScope),
+                operationKind: 'action',
+                operation: operation.operation,
+            }));
+        }
+        for (const operation of group.dataActions) {
+            currentOperationKeys.add(permissionChangeOperationKey({
+                groupHash: String(group.groupHash),
+                providerScopeId: String(group.providerScopeId),
+                exactAssignmentScope: String(group.exactAssignmentScope),
+                operationKind: 'data-action',
+                operation: operation.operation,
+            }));
+        }
+    }
+    if ((value.change.status === 'new' || value.change.status === 'missing') &&
+        (addedKeys.size !== currentOperationKeys.size || [...currentOperationKeys].some(key => !addedKeys.has(key)))) {
+        return false;
+    }
+    return (change.addedOperations.every(operation => currentOperationKeys.has(permissionChangeOperationKey(operation))) &&
+        change.removedOperations.every(operation => !currentOperationKeys.has(permissionChangeOperationKey(operation))));
+}
+function permissionChangeOperationKey(value) {
+    return [value.groupHash, value.providerScopeId, value.exactAssignmentScope, value.operationKind, value.operation]
+        .map(item => item.toLowerCase())
+        .join('\u0000');
+}
+function isPermissionChangeOperations(value) {
+    return (Array.isArray(value) &&
+        value.length <= RESOURCE_STRATEGY_CONTRACT_LIMITS.permissionOperations &&
+        value.every(item => isRecord(item) &&
+            hasOnlyKeys(item, ['groupHash', 'providerScopeId', 'exactAssignmentScope', 'operationKind', 'operation']) &&
+            isBoundedString(item.groupHash, 200) &&
+            isBoundedString(item.providerScopeId, 300) &&
+            isBoundedString(item.exactAssignmentScope, 2000) &&
+            ['action', 'data-action'].includes(String(item.operationKind)) &&
+            isBoundedString(item.operation, 500) &&
+            !item.operation.includes('*')));
+}
+function isPermissionOperations(value) {
+    if (!Array.isArray(value) || value.length > RESOURCE_STRATEGY_CONTRACT_LIMITS.metadataItems)
+        return false;
+    const operations = new Set();
+    return value.every(item => {
+        if (!isRecord(item) ||
+            !hasOnlyKeys(item, ['operation', 'permissionSetRefs', 'reason', 'evidenceUrl']) ||
+            !isBoundedString(item.operation, 500) ||
+            item.operation.includes('*') ||
+            !Array.isArray(item.permissionSetRefs) ||
+            item.permissionSetRefs.length === 0 ||
+            !isBoundedStringArray(item.permissionSetRefs) ||
+            new Set(item.permissionSetRefs).size !== item.permissionSetRefs.length ||
+            !isBoundedString(item.reason, 2000) ||
+            !isBoundedString(item.evidenceUrl, 2000) ||
+            operations.has(item.operation.toLowerCase())) {
+            return false;
+        }
+        operations.add(item.operation.toLowerCase());
+        return true;
+    });
+}
+export function isResourceSchedulePermissionManifestConsent(value) {
+    return (isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) &&
+        isRecord(value) &&
+        hasOnlyKeys(value, ['version', 'contentHash', 'orderedGrantGroupHashes']) &&
+        isBoundedString(value.version, 200) &&
+        isBoundedString(value.contentHash, 200) &&
+        Array.isArray(value.orderedGrantGroupHashes) &&
+        value.orderedGrantGroupHashes.length > 0 &&
+        value.orderedGrantGroupHashes.length <= RESOURCE_STRATEGY_CONTRACT_LIMITS.grantGroups &&
+        value.orderedGrantGroupHashes.every(item => isBoundedString(item, 200)) &&
+        new Set(value.orderedGrantGroupHashes).size === value.orderedGrantGroupHashes.length);
+}

package/dist/esm/scheduler/resourceStrategyScheduleValidation.js

@@ -0,0 +1,332 @@
+import { RESOURCE_STRATEGY_CONTRACT_LIMITS, } from './resourceStrategyContracts.js';
+import { containsForbiddenKey, hasOnlyKeys, isBoundedParameters, isBoundedString, isCapabilityRef, isDate, isIanaTimezone, isIsoTimestamp, isNonNegativeInteger, isOptionalBoundedString, isPositiveInteger, isRecord, isTime, isWithinJsonByteLimit, } from './resourceStrategyValidationShared.js';
+function isWeeklyRule(value) {
+    return (isRecord(value) &&
+        hasOnlyKeys(value, ['ruleId', 'transition', 'daysOfWeek', 'desiredStateAtLocal', 'parameters']) &&
+        isBoundedString(value.ruleId, 200) &&
+        (value.transition === 'reduce' || value.transition === 'restore') &&
+        Array.isArray(value.daysOfWeek) &&
+        value.daysOfWeek.length > 0 &&
+        value.daysOfWeek.length <= RESOURCE_STRATEGY_CONTRACT_LIMITS.ruleDays &&
+        new Set(value.daysOfWeek).size === value.daysOfWeek.length &&
+        value.daysOfWeek.every(day => Number.isInteger(day) && day >= 0 && day <= 6) &&
+        isTime(value.desiredStateAtLocal) &&
+        (value.parameters === undefined || isBoundedParameters(value.parameters)));
+}
+export function isResourceStrategyWeeklyScheduleSuggestion(value) {
+    if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) || !isRecord(value) || containsForbiddenKey(value))
+        return false;
+    if (!hasOnlyKeys(value, [
+        'definitionType',
+        'capability',
+        'defaultParameters',
+        'rules',
+        'busyPolicy',
+        'blackoutDatesLocal',
+        'activeFromUtc',
+        'activeUntilUtc',
+        'acknowledgementVersion',
+        'firstExecutionAcknowledgementVersion',
+    ]) ||
+        value.definitionType !== 'resource-strategy-weekly' ||
+        !isCapabilityRef(value.capability) ||
+        (value.defaultParameters !== undefined && !isBoundedParameters(value.defaultParameters)) ||
+        !Array.isArray(value.rules) ||
+        value.rules.length === 0 ||
+        value.rules.length > RESOURCE_STRATEGY_CONTRACT_LIMITS.rules ||
+        !value.rules.every(isWeeklyRule) ||
+        new Set(value.rules.map(rule => rule.ruleId)).size !== value.rules.length ||
+        !isOptionalBoundedString(value.acknowledgementVersion, 200) ||
+        !isOptionalBoundedString(value.firstExecutionAcknowledgementVersion, 200)) {
+        return false;
+    }
+    if (value.busyPolicy !== undefined) {
+        if (!isRecord(value.busyPolicy) ||
+            !hasOnlyKeys(value.busyPolicy, ['mode', 'maxDelayMinutes']) ||
+            !['skip', 'wait-until-deadline', 'force'].includes(String(value.busyPolicy.mode)) ||
+            (value.busyPolicy.maxDelayMinutes !== undefined && !isNonNegativeInteger(value.busyPolicy.maxDelayMinutes))) {
+            return false;
+        }
+    }
+    if (value.blackoutDatesLocal !== undefined &&
+        (!Array.isArray(value.blackoutDatesLocal) ||
+            value.blackoutDatesLocal.length > RESOURCE_STRATEGY_CONTRACT_LIMITS.metadataItems ||
+            !value.blackoutDatesLocal.every(isDate))) {
+        return false;
+    }
+    if (value.activeFromUtc !== undefined && !isIsoTimestamp(value.activeFromUtc))
+        return false;
+    if (value.activeUntilUtc !== undefined && !isIsoTimestamp(value.activeUntilUtc))
+        return false;
+    if (typeof value.activeFromUtc === 'string' &&
+        typeof value.activeUntilUtc === 'string' &&
+        Date.parse(value.activeFromUtc) > Date.parse(value.activeUntilUtc)) {
+        return false;
+    }
+    return true;
+}
+export function isResourceStrategyWeeklyScheduleWriteRequest(value) {
+    if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) || !isRecord(value) || containsForbiddenKey(value))
+        return false;
+    if (!hasOnlyKeys(value, [
+        'definitionType',
+        'providerScopeId',
+        'cloudAccountId',
+        'resourceId',
+        'capability',
+        'name',
+        'timezone',
+        'defaultParameters',
+        'rules',
+        'busyPolicy',
+        'blackoutDatesLocal',
+        'activeFromUtc',
+        'activeUntilUtc',
+        'initialMode',
+        'notificationPolicyId',
+        'acknowledgementVersion',
+        'firstExecutionAcknowledgementVersion',
+        'notes',
+    ])) {
+        return false;
+    }
+    if (value.definitionType !== 'resource-strategy-weekly' ||
+        !isBoundedString(value.providerScopeId, 300) ||
+        !isBoundedString(value.cloudAccountId, 200) ||
+        !isBoundedString(value.resourceId, 2000) ||
+        !isCapabilityRef(value.capability) ||
+        !isBoundedString(value.name) ||
+        !isIanaTimezone(value.timezone) ||
+        (value.defaultParameters !== undefined && !isBoundedParameters(value.defaultParameters)) ||
+        !Array.isArray(value.rules) ||
+        value.rules.length === 0 ||
+        value.rules.length > RESOURCE_STRATEGY_CONTRACT_LIMITS.rules ||
+        !value.rules.every(isWeeklyRule) ||
+        new Set(value.rules.map(rule => rule.ruleId)).size !== value.rules.length ||
+        !['draft', 'dry-run', 'active'].includes(String(value.initialMode)) ||
+        !isBoundedString(value.notificationPolicyId, 200) ||
+        !isOptionalBoundedString(value.acknowledgementVersion, 200) ||
+        !isOptionalBoundedString(value.firstExecutionAcknowledgementVersion, 200) ||
+        !isOptionalBoundedString(value.notes)) {
+        return false;
+    }
+    if (value.busyPolicy !== undefined) {
+        if (!isRecord(value.busyPolicy) ||
+            !hasOnlyKeys(value.busyPolicy, ['mode', 'maxDelayMinutes']) ||
+            !['skip', 'wait-until-deadline', 'force'].includes(String(value.busyPolicy.mode)) ||
+            (value.busyPolicy.maxDelayMinutes !== undefined && !isNonNegativeInteger(value.busyPolicy.maxDelayMinutes))) {
+            return false;
+        }
+    }
+    if (value.blackoutDatesLocal !== undefined &&
+        (!Array.isArray(value.blackoutDatesLocal) ||
+            value.blackoutDatesLocal.length > RESOURCE_STRATEGY_CONTRACT_LIMITS.metadataItems ||
+            !value.blackoutDatesLocal.every(isDate))) {
+        return false;
+    }
+    if (value.activeFromUtc !== undefined && !isIsoTimestamp(value.activeFromUtc))
+        return false;
+    if (value.activeUntilUtc !== undefined && !isIsoTimestamp(value.activeUntilUtc))
+        return false;
+    if (typeof value.activeFromUtc === 'string' &&
+        typeof value.activeUntilUtc === 'string' &&
+        Date.parse(value.activeFromUtc) > Date.parse(value.activeUntilUtc)) {
+        return false;
+    }
+    return true;
+}
+export function isResourceStrategyWeeklyScheduleProjection(value) {
+    if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) ||
+        !isRecord(value) ||
+        !hasOnlyKeys(value, [
+            'scheduleId',
+            'definitionRevision',
+            'controlGeneration',
+            'etag',
+            'status',
+            'definition',
+            'permissionManifest',
+            'createdAtUtc',
+            'createdBy',
+            'updatedAtUtc',
+            'updatedBy',
+            'acknowledgement',
+            'firstExecutionAcknowledgement',
+        ])) {
+        return false;
+    }
+    const isAcknowledgement = (item) => isRecord(item) &&
+        hasOnlyKeys(item, ['version', 'acknowledgedAtUtc', 'acknowledgedBy']) &&
+        isBoundedString(item.version, 200) &&
+        isIsoTimestamp(item.acknowledgedAtUtc) &&
+        isBoundedString(item.acknowledgedBy, 200);
+    return (isBoundedString(value.scheduleId, 200) &&
+        isPositiveInteger(value.definitionRevision) &&
+        isPositiveInteger(value.controlGeneration) &&
+        isBoundedString(value.etag, 500) &&
+        ['draft', 'dry-run', 'active', 'paused', 'restore-only'].includes(String(value.status)) &&
+        isResourceStrategyWeeklyScheduleWriteRequest(value.definition) &&
+        isManifestRef(value.permissionManifest) &&
+        isIsoTimestamp(value.createdAtUtc) &&
+        isBoundedString(value.createdBy, 200) &&
+        isIsoTimestamp(value.updatedAtUtc) &&
+        isBoundedString(value.updatedBy, 200) &&
+        (value.acknowledgement === undefined || isAcknowledgement(value.acknowledgement)) &&
+        (value.firstExecutionAcknowledgement === undefined || isAcknowledgement(value.firstExecutionAcknowledgement)));
+}
+function isManifestRef(value) {
+    return (isRecord(value) &&
+        hasOnlyKeys(value, ['version', 'contentHash']) &&
+        isBoundedString(value.version, 200) &&
+        isBoundedString(value.contentHash, 200));
+}
+export function isScheduledResourceTransitionV1(value) {
+    return (isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) &&
+        isRecord(value) &&
+        !containsForbiddenKey(value.parameters) &&
+        hasOnlyKeys(value, [
+            'schemaVersion',
+            'companyId',
+            'providerScopeId',
+            'cloudAccountId',
+            'resourceId',
+            'scheduleId',
+            'definitionRevision',
+            'controlGeneration',
+            'ruleId',
+            'occurrenceKey',
+            'scheduleRunId',
+            'desiredStateAtUtc',
+            'dispatchNotBeforeUtc',
+            'reduceDeadlineUtc',
+            'capability',
+            'transition',
+            'parameters',
+            'permissionManifest',
+            'correlationId',
+        ]) &&
+        value.schemaVersion === 1 &&
+        isBoundedString(value.companyId, 200) &&
+        isBoundedString(value.providerScopeId, 300) &&
+        isBoundedString(value.cloudAccountId, 200) &&
+        isBoundedString(value.resourceId, 2000) &&
+        isBoundedString(value.scheduleId, 200) &&
+        isPositiveInteger(value.definitionRevision) &&
+        isPositiveInteger(value.controlGeneration) &&
+        isBoundedString(value.ruleId, 200) &&
+        isBoundedString(value.occurrenceKey, 500) &&
+        isBoundedString(value.scheduleRunId, 200) &&
+        isIsoTimestamp(value.desiredStateAtUtc) &&
+        isIsoTimestamp(value.dispatchNotBeforeUtc) &&
+        (value.reduceDeadlineUtc === undefined || isIsoTimestamp(value.reduceDeadlineUtc)) &&
+        isCapabilityRef(value.capability) &&
+        (value.transition === 'reduce' || value.transition === 'restore') &&
+        isBoundedParameters(value.parameters) &&
+        isManifestRef(value.permissionManifest) &&
+        isBoundedString(value.correlationId, 200));
+}
+export function isResourceSchedulingExecutionProjection(value) {
+    if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) ||
+        !isRecord(value) ||
+        !hasOnlyKeys(value, [
+            'companyId',
+            'resourceId',
+            'scheduleId',
+            'definitionRevision',
+            'controlGeneration',
+            'lifecycleState',
+            'activeRecoveryCycleId',
+            'restoreOwed',
+            'lastRun',
+            'allowedCommands',
+            'updatedAtUtc',
+        ])) {
+        return false;
+    }
+    if (value.lastRun !== undefined) {
+        const lastRun = value.lastRun;
+        if (!isRecord(lastRun) ||
+            !hasOnlyKeys(lastRun, ['scheduleRunId', 'transition', 'phase', 'outcome', 'desiredStateAtUtc', 'updatedAtUtc', 'reasonCode']) ||
+            !isBoundedString(lastRun.scheduleRunId, 200) ||
+            !['reduce', 'restore'].includes(String(lastRun.transition)) ||
+            (lastRun.phase !== undefined &&
+                !['queued', 'leased', 'preflight', 'capturing-baseline', 'executing', 'polling', 'verifying'].includes(String(lastRun.phase))) ||
+            (lastRun.outcome !== undefined &&
+                !['succeeded', 'no-op', 'skipped', 'blocked', 'failed', 'superseded', 'expired'].includes(String(lastRun.outcome))) ||
+            !isIsoTimestamp(lastRun.desiredStateAtUtc) ||
+            !isIsoTimestamp(lastRun.updatedAtUtc) ||
+            !isOptionalBoundedString(lastRun.reasonCode, 200)) {
+            return false;
+        }
+        if ((lastRun.phase === undefined) === (lastRun.outcome === undefined))
+            return false;
+    }
+    return (isBoundedString(value.companyId, 200) &&
+        isBoundedString(value.resourceId, 2000) &&
+        isOptionalBoundedString(value.scheduleId, 200) &&
+        (value.definitionRevision === undefined || isPositiveInteger(value.definitionRevision)) &&
+        isPositiveInteger(value.controlGeneration) &&
+        ['unknown', 'normal', 'reducing', 'reduced', 'restoring', 'reduce-failed', 'restore-failed', 'drifted', 'target-missing', 'stranded'].includes(String(value.lifecycleState)) &&
+        isOptionalBoundedString(value.activeRecoveryCycleId, 200) &&
+        typeof value.restoreOwed === 'boolean' &&
+        Array.isArray(value.allowedCommands) &&
+        value.allowedCommands.length <= 4 &&
+        new Set(value.allowedCommands).size === value.allowedCommands.length &&
+        value.allowedCommands.every(command => ['pause', 'resume', 'restore-now', 'leave-current-state'].includes(String(command))) &&
+        isIsoTimestamp(value.updatedAtUtc));
+}
+function isResourceSchedulingExecutionHistoryItem(value) {
+    return (isRecord(value) &&
+        hasOnlyKeys(value, [
+            'scheduleRunId',
+            'resourceId',
+            'transition',
+            'desiredStateAtUtc',
+            'claimedAtUtc',
+            'completedAtUtc',
+            'outcome',
+            'reasonCode',
+            'attemptCount',
+        ]) &&
+        isBoundedString(value.scheduleRunId, 200) &&
+        isBoundedString(value.resourceId, 2000) &&
+        (value.transition === 'reduce' || value.transition === 'restore') &&
+        isIsoTimestamp(value.desiredStateAtUtc) &&
+        isIsoTimestamp(value.claimedAtUtc) &&
+        (value.completedAtUtc === undefined || isIsoTimestamp(value.completedAtUtc)) &&
+        (value.outcome === undefined ||
+            ['succeeded', 'no-op', 'skipped', 'blocked', 'failed', 'superseded', 'expired'].includes(String(value.outcome))) &&
+        isOptionalBoundedString(value.reasonCode, 200) &&
+        isPositiveInteger(value.attemptCount) &&
+        ((value.completedAtUtc === undefined && value.outcome === undefined) || (value.completedAtUtc !== undefined && value.outcome !== undefined)));
+}
+export function isResourceSchedulingExecutionHistoryResponse(value) {
+    return (isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) &&
+        isRecord(value) &&
+        hasOnlyKeys(value, ['execution', 'runs']) &&
+        isResourceSchedulingExecutionProjection(value.execution) &&
+        Array.isArray(value.runs) &&
+        value.runs.length <= 100 &&
+        value.runs.every(isResourceSchedulingExecutionHistoryItem));
+}
+export function isResourceStrategyScheduleCommand(value) {
+    if (!isWithinJsonByteLimit(value, RESOURCE_STRATEGY_CONTRACT_LIMITS.publicDtoBytes) ||
+        !isRecord(value) ||
+        !hasOnlyKeys(value, ['command', 'idempotencyKey', 'acknowledgement']) ||
+        !isBoundedString(value.idempotencyKey, 200)) {
+        return false;
+    }
+    if (value.command === 'leave-current-state')
+        return isBoundedString(value.acknowledgement, 2000);
+    return ['pause', 'resume', 'restore-now'].includes(String(value.command)) && value.acknowledgement === undefined;
+}
+export function isResourceStrategyWeeklyScheduleListResponse(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(isResourceStrategyWeeklyScheduleProjection) &&
+        (value.continuation === undefined ||
+            (isRecord(value.continuation) && hasOnlyKeys(value.continuation, ['cursor']) && isBoundedString(value.continuation.cursor, 2000))));
+}

package/dist/esm/scheduler/resourceStrategyValidation.js

@@ -0,0 +1,4 @@
+export * from './resourceStrategyCapabilityValidation.js';
+export * from './resourceStrategyFinancialValidation.js';
+export * from './resourceStrategyPermissionValidation.js';
+export * from './resourceStrategyScheduleValidation.js';