Merge branch 'main' into feature/featcx-api-throw-cloudassemblyerror-instead-of-unt

mergify[bot] · web-flow · commit 899a19adb7c6 · 2025-02-12T11:29:35.000Z
diff --git a/packages/aws-cdk-lib/.eslintrc.js b/packages/aws-cdk-lib/.eslintrc.js
@@ -16,6 +16,7 @@ baseConfig.rules['import/no-extraneous-dependencies'] = [
 
 // no-throw-default-error
 const enableNoThrowDefaultErrorIn = [
+  'aws-backup',
   'assets',
   'aws-amplify',
   'aws-amplifyuibuilder',
@@ -27,6 +28,8 @@ const enableNoThrowDefaultErrorIn = [
   'aws-applicationautoscaling',
   'aws-appsync',
   'aws-appmesh',
+  'aws-autoscaling',
+  'aws-autoscaling-common',  
   'aws-batch',
   'aws-cognito',
   'aws-elasticloadbalancing',
diff --git a/packages/aws-cdk-lib/aws-autoscaling-common/lib/interval-utils.ts b/packages/aws-cdk-lib/aws-autoscaling-common/lib/interval-utils.ts
@@ -1,4 +1,5 @@
 import { ScalingInterval } from './types';
+import { UnscopedValidationError } from '../../core';
 
 export interface CompleteScalingInterval {
   readonly lower: number;
@@ -30,12 +31,12 @@ export function normalizeIntervals(intervals: ScalingInterval[], changesAreAbsol
  */
 function orderAndCompleteIntervals(intervals: ScalingInterval[]): CompleteScalingInterval[] {
   if (intervals.length < 2) {
-    throw new Error('Require at least 2 intervals');
+    throw new UnscopedValidationError('Require at least 2 intervals');
   }
 
   for (const interval of intervals) {
     if (interval.lower === undefined && interval.upper === undefined) {
-      throw new Error(`Must supply at least one of 'upper' or 'lower', got: ${JSON.stringify(interval)}`);
+      throw new UnscopedValidationError(`Must supply at least one of 'upper' or 'lower', got: ${JSON.stringify(interval)}`);
     }
   }
 
@@ -55,7 +56,7 @@ function orderAndCompleteIntervals(intervals: ScalingInterval[]): CompleteScalin
   if (intervals[lastIndex].upper === undefined) { intervals[lastIndex] = { ...intervals[lastIndex], upper: Infinity }; }
   for (const interval of intervals) {
     if (interval.lower === undefined || interval.upper === undefined) {
-      throw new Error(`Could not determine the lower and upper bounds for ${JSON.stringify(interval)}`);
+      throw new UnscopedValidationError(`Could not determine the lower and upper bounds for ${JSON.stringify(interval)}`);
     }
   }
 
@@ -64,7 +65,7 @@ function orderAndCompleteIntervals(intervals: ScalingInterval[]): CompleteScalin
   // Validate that we have nonoverlapping intervals now.
   for (let i = 0; i < completeIntervals.length - 1; i++) {
     if (overlap(completeIntervals[i], completeIntervals[i + 1])) {
-      throw new Error(`Two intervals overlap: ${JSON.stringify(completeIntervals[i])} and ${JSON.stringify(completeIntervals[i + 1])}`);
+      throw new UnscopedValidationError(`Two intervals overlap: ${JSON.stringify(completeIntervals[i])} and ${JSON.stringify(completeIntervals[i + 1])}`);
     }
   }
 
@@ -148,7 +149,7 @@ function combineUndefineds(intervals: CompleteScalingInterval[]) {
 function validateAtMostOneUndefined(intervals: CompleteScalingInterval[]) {
   const undef = intervals.filter(x => x.change === undefined);
   if (undef.length > 1) {
-    throw new Error(`Can have at most one no-change interval, got ${JSON.stringify(undef)}`);
+    throw new UnscopedValidationError(`Can have at most one no-change interval, got ${JSON.stringify(undef)}`);
   }
 }
 
diff --git a/packages/aws-cdk-lib/aws-autoscaling/lib/auto-scaling-group.ts b/packages/aws-cdk-lib/aws-autoscaling/lib/auto-scaling-group.ts
diff --git a/packages/aws-cdk-lib/aws-autoscaling/lib/lifecycle-hook.ts b/packages/aws-cdk-lib/aws-autoscaling/lib/lifecycle-hook.ts
@@ -3,7 +3,7 @@ import { IAutoScalingGroup } from './auto-scaling-group';
 import { CfnLifecycleHook } from './autoscaling.generated';
 import { ILifecycleHookTarget } from './lifecycle-hook-target';
 import * as iam from '../../aws-iam';
-import { Duration, IResource, Resource } from '../../core';
+import { Duration, IResource, Resource, ValidationError } from '../../core';
 import { addConstructMetadata } from '../../core/lib/metadata-resource';
 
 /**
@@ -97,7 +97,7 @@ export class LifecycleHook extends Resource implements ILifecycleHook {
    */
   public get role() {
     if (!this._role) {
-      throw new Error('\'role\' is undefined. Please specify a \'role\' or specify a \'notificationTarget\' to have a role provided for you.');
+      throw new ValidationError('\'role\' is undefined. Please specify a \'role\' or specify a \'notificationTarget\' to have a role provided for you.', this);
     }
 
     return this._role;
@@ -122,7 +122,7 @@ export class LifecycleHook extends Resource implements ILifecycleHook {
       this._role = props.role;
 
       if (!props.notificationTarget) {
-        throw new Error("'notificationTarget' parameter required when 'role' parameter is specified");
+        throw new ValidationError("'notificationTarget' parameter required when 'role' parameter is specified", this);
       }
     } else {
       this._role = targetProps ? targetProps.createdRole : undefined;
diff --git a/packages/aws-cdk-lib/aws-autoscaling/lib/schedule.ts b/packages/aws-cdk-lib/aws-autoscaling/lib/schedule.ts
@@ -1,5 +1,5 @@
 import { Construct } from 'constructs';
-import { Annotations } from '../../core';
+import { Annotations, UnscopedValidationError } from '../../core';
 
 /**
  * Schedule for scheduled scaling actions
@@ -20,7 +20,7 @@ export abstract class Schedule {
    */
   public static cron(options: CronOptions): Schedule {
     if (options.weekDay !== undefined && options.day !== undefined) {
-      throw new Error('Cannot supply both \'day\' and \'weekDay\', use at most one');
+      throw new UnscopedValidationError('Cannot supply both \'day\' and \'weekDay\', use at most one');
     }
 
     const minute = fallback(options.minute, '*');
diff --git a/packages/aws-cdk-lib/aws-autoscaling/lib/scheduled-action.ts b/packages/aws-cdk-lib/aws-autoscaling/lib/scheduled-action.ts
@@ -2,7 +2,7 @@ import { Construct } from 'constructs';
 import { IAutoScalingGroup } from './auto-scaling-group';
 import { CfnScheduledAction } from './autoscaling.generated';
 import { Schedule } from './schedule';
-import { Resource } from '../../core';
+import { Resource, ValidationError } from '../../core';
 import { addConstructMetadata } from '../../core/lib/metadata-resource';
 
 /**
@@ -104,7 +104,7 @@ export class ScheduledAction extends Resource {
     addConstructMetadata(this, props);
 
     if (props.minCapacity === undefined && props.maxCapacity === undefined && props.desiredCapacity === undefined) {
-      throw new Error('At least one of minCapacity, maxCapacity, or desiredCapacity is required');
+      throw new ValidationError('At least one of minCapacity, maxCapacity, or desiredCapacity is required', this);
     }
 
     // add a warning on synth when minute is not defined in a cron schedule
diff --git a/packages/aws-cdk-lib/aws-autoscaling/lib/step-scaling-action.ts b/packages/aws-cdk-lib/aws-autoscaling/lib/step-scaling-action.ts
@@ -1,7 +1,7 @@
 import { Construct } from 'constructs';
 import { IAutoScalingGroup } from './auto-scaling-group';
 import { CfnScalingPolicy } from './autoscaling.generated';
-import { Annotations, Duration, Lazy } from '../../core';
+import { Annotations, Duration, Lazy, ValidationError } from '../../core';
 
 /**
  * Properties for a scaling policy
@@ -97,7 +97,7 @@ export class StepScalingAction extends Construct {
    */
   public addAdjustment(adjustment: AdjustmentTier) {
     if (adjustment.lowerBound === undefined && adjustment.upperBound === undefined) {
-      throw new Error('At least one of lowerBound or upperBound is required');
+      throw new ValidationError('At least one of lowerBound or upperBound is required', this);
     }
     this.adjustments.push({
       metricIntervalLowerBound: adjustment.lowerBound,
diff --git a/packages/aws-cdk-lib/aws-autoscaling/lib/step-scaling-policy.ts b/packages/aws-cdk-lib/aws-autoscaling/lib/step-scaling-policy.ts
@@ -3,7 +3,7 @@ import { IAutoScalingGroup } from './auto-scaling-group';
 import { AdjustmentType, MetricAggregationType, StepScalingAction } from './step-scaling-action';
 import { findAlarmThresholds, normalizeIntervals } from '../../aws-autoscaling-common';
 import * as cloudwatch from '../../aws-cloudwatch';
-import { Duration, Token } from '../../core';
+import { Duration, Token, ValidationError } from '../../core';
 
 export interface BasicStepScalingPolicyProps {
   /**
@@ -112,28 +112,28 @@ export class StepScalingPolicy extends Construct {
     super(scope, id);
 
     if (props.scalingSteps.length < 2) {
-      throw new Error('You must supply at least 2 intervals for autoscaling');
+      throw new ValidationError('You must supply at least 2 intervals for autoscaling', this);
     }
 
     if (props.scalingSteps.length > 40) {
-      throw new Error(`'scalingSteps' can have at most 40 steps, got ${props.scalingSteps.length}`);
+      throw new ValidationError(`'scalingSteps' can have at most 40 steps, got ${props.scalingSteps.length}`, this);
     }
 
     if (props.evaluationPeriods !== undefined && !Token.isUnresolved(props.evaluationPeriods) && props.evaluationPeriods < 1) {
-      throw new Error(`evaluationPeriods cannot be less than 1, got: ${props.evaluationPeriods}`);
+      throw new ValidationError(`evaluationPeriods cannot be less than 1, got: ${props.evaluationPeriods}`, this);
     }
     if (props.datapointsToAlarm !== undefined) {
       if (props.evaluationPeriods === undefined) {
-        throw new Error('evaluationPeriods must be set if datapointsToAlarm is set');
+        throw new ValidationError('evaluationPeriods must be set if datapointsToAlarm is set', this);
       }
       if (!Token.isUnresolved(props.datapointsToAlarm) && props.datapointsToAlarm < 1) {
-        throw new Error(`datapointsToAlarm cannot be less than 1, got: ${props.datapointsToAlarm}`);
+        throw new ValidationError(`datapointsToAlarm cannot be less than 1, got: ${props.datapointsToAlarm}`, this);
       }
       if (!Token.isUnresolved(props.datapointsToAlarm)
         && !Token.isUnresolved(props.evaluationPeriods)
         && props.evaluationPeriods < props.datapointsToAlarm
       ) {
-        throw new Error(`datapointsToAlarm must be less than or equal to evaluationPeriods, got datapointsToAlarm: ${props.datapointsToAlarm}, evaluationPeriods: ${props.evaluationPeriods}`);
+        throw new ValidationError(`datapointsToAlarm must be less than or equal to evaluationPeriods, got datapointsToAlarm: ${props.datapointsToAlarm}, evaluationPeriods: ${props.evaluationPeriods}`, this);
       }
     }
 
diff --git a/packages/aws-cdk-lib/aws-autoscaling/lib/target-tracking-scaling-policy.ts b/packages/aws-cdk-lib/aws-autoscaling/lib/target-tracking-scaling-policy.ts
@@ -2,7 +2,7 @@ import { Construct } from 'constructs';
 import { IAutoScalingGroup } from './auto-scaling-group';
 import { CfnScalingPolicy } from './autoscaling.generated';
 import * as cloudwatch from '../../aws-cloudwatch';
-import { Duration } from '../../core';
+import { Duration, ValidationError } from '../../core';
 
 /**
  * Base interface for target tracking props
@@ -110,20 +110,20 @@ export class TargetTrackingScalingPolicy extends Construct {
   private resource: CfnScalingPolicy;
 
   constructor(scope: Construct, id: string, props: TargetTrackingScalingPolicyProps) {
+    super(scope, id);
+
     if ((props.customMetric === undefined) === (props.predefinedMetric === undefined)) {
-      throw new Error('Exactly one of \'customMetric\' or \'predefinedMetric\' must be specified.');
+      throw new ValidationError('Exactly one of \'customMetric\' or \'predefinedMetric\' must be specified.', this);
     }
 
     if (props.predefinedMetric === PredefinedMetric.ALB_REQUEST_COUNT_PER_TARGET && !props.resourceLabel) {
-      throw new Error('When tracking the ALBRequestCountPerTarget metric, the ALB identifier must be supplied in resourceLabel');
+      throw new ValidationError('When tracking the ALBRequestCountPerTarget metric, the ALB identifier must be supplied in resourceLabel', this);
     }
 
     if (props.customMetric && !props.customMetric.toMetricConfig().metricStat) {
-      throw new Error('Only direct metrics are supported for Target Tracking. Use Step Scaling or supply a Metric object.');
+      throw new ValidationError('Only direct metrics are supported for Target Tracking. Use Step Scaling or supply a Metric object.', this);
     }
 
-    super(scope, id);
-
     this.resource = new CfnScalingPolicy(this, 'Resource', {
       policyType: 'TargetTrackingScaling',
       autoScalingGroupName: props.autoScalingGroup.autoScalingGroupName,
diff --git a/packages/aws-cdk-lib/aws-autoscaling/lib/volume.ts b/packages/aws-cdk-lib/aws-autoscaling/lib/volume.ts
@@ -2,6 +2,8 @@
 // existed first in the "autoscaling" module before it existed in the "ec2"
 // module so we couldn't standardize the structs in the right way.
 
+import { UnscopedValidationError } from '../../core';
+
 /**
  * Block device
  */
@@ -154,7 +156,7 @@ export class BlockDeviceVolume {
    */
   public static ephemeral(volumeIndex: number) {
     if (volumeIndex < 0) {
-      throw new Error(`volumeIndex must be a number starting from 0, got "${volumeIndex}"`);
+      throw new UnscopedValidationError(`volumeIndex must be a number starting from 0, got "${volumeIndex}"`);
     }
 
     return new this(undefined, `ephemeral${volumeIndex}`);
diff --git a/packages/aws-cdk-lib/aws-autoscaling/lib/warm-pool.ts b/packages/aws-cdk-lib/aws-autoscaling/lib/warm-pool.ts
@@ -1,7 +1,7 @@
 import { Construct } from 'constructs';
 import { IAutoScalingGroup } from './auto-scaling-group';
 import { CfnWarmPool } from './autoscaling.generated';
-import { Lazy, Names, Resource } from '../../core';
+import { Lazy, Names, Resource, ValidationError } from '../../core';
 import { addConstructMetadata } from '../../core/lib/metadata-resource';
 
 /**
@@ -64,11 +64,11 @@ export class WarmPool extends Resource {
     addConstructMetadata(this, props);
 
     if (props.maxGroupPreparedCapacity && props.maxGroupPreparedCapacity < -1) {
-      throw new Error('\'maxGroupPreparedCapacity\' parameter should be greater than or equal to -1');
+      throw new ValidationError('\'maxGroupPreparedCapacity\' parameter should be greater than or equal to -1', this);
     }
 
     if (props.minSize && props.minSize < 0) {
-      throw new Error('\'minSize\' parameter should be greater than or equal to 0');
+      throw new ValidationError('\'minSize\' parameter should be greater than or equal to 0', this);
     }
 
     new CfnWarmPool(this, 'Resource', {
diff --git a/packages/aws-cdk-lib/aws-backup/lib/plan.ts b/packages/aws-cdk-lib/aws-backup/lib/plan.ts
@@ -3,7 +3,7 @@ import { CfnBackupPlan } from './backup.generated';
 import { BackupPlanCopyActionProps, BackupPlanRule } from './rule';
 import { BackupSelection, BackupSelectionOptions } from './selection';
 import { BackupVault, IBackupVault } from './vault';
-import { IResource, Lazy, Resource } from '../../core';
+import { IResource, Lazy, Resource, ValidationError } from '../../core';
 import { addConstructMetadata, MethodMetadata } from '../../core/lib/metadata-resource';
 
 /**
@@ -217,7 +217,7 @@ export class BackupPlan extends Resource implements IBackupPlan {
   public get backupVault(): IBackupVault {
     if (!this._backupVault) {
       // This cannot happen but is here to make TypeScript happy
-      throw new Error('No backup vault!');
+      throw new ValidationError('No backup vault!', this);
     }
 
     return this._backupVault;
diff --git a/packages/aws-cdk-lib/aws-backup/lib/rule.ts b/packages/aws-cdk-lib/aws-backup/lib/rule.ts
@@ -1,6 +1,6 @@
 import { IBackupVault } from './vault';
 import * as events from '../../aws-events';
-import { Duration, Token } from '../../core';
+import { Duration, Token, UnscopedValidationError } from '../../core';
 
 /**
  * Properties for a BackupPlanRule
@@ -206,30 +206,30 @@ export class BackupPlanRule {
   constructor(props: BackupPlanRuleProps) {
     if (props.deleteAfter && props.moveToColdStorageAfter &&
       props.deleteAfter.toDays() < props.moveToColdStorageAfter.toDays()) {
-      throw new Error('`deleteAfter` must be greater than `moveToColdStorageAfter`');
+      throw new UnscopedValidationError('`deleteAfter` must be greater than `moveToColdStorageAfter`');
     }
 
     if (props.scheduleExpression && !/^cron/.test(props.scheduleExpression.expressionString)) {
-      throw new Error('`scheduleExpression` must be of type `cron`');
+      throw new UnscopedValidationError('`scheduleExpression` must be of type `cron`');
     }
 
     const deleteAfter = (props.enableContinuousBackup && !props.deleteAfter) ? Duration.days(35) : props.deleteAfter;
 
     if (props.enableContinuousBackup && props.moveToColdStorageAfter) {
-      throw new Error('`moveToColdStorageAfter` must not be specified if `enableContinuousBackup` is enabled');
+      throw new UnscopedValidationError('`moveToColdStorageAfter` must not be specified if `enableContinuousBackup` is enabled');
     }
 
     if (props.enableContinuousBackup && props.deleteAfter &&
       (props.deleteAfter?.toDays() < 1 || props.deleteAfter?.toDays() > 35)) {
-      throw new Error(`'deleteAfter' must be between 1 and 35 days if 'enableContinuousBackup' is enabled, but got ${props.deleteAfter.toHumanString()}`);
+      throw new UnscopedValidationError(`'deleteAfter' must be between 1 and 35 days if 'enableContinuousBackup' is enabled, but got ${props.deleteAfter.toHumanString()}`);
     }
 
     if (props.copyActions && props.copyActions.length > 0) {
       props.copyActions.forEach(copyAction => {
         if (copyAction.deleteAfter && !Token.isUnresolved(copyAction.deleteAfter) &&
           copyAction.moveToColdStorageAfter && !Token.isUnresolved(copyAction.moveToColdStorageAfter) &&
           copyAction.deleteAfter.toDays() < copyAction.moveToColdStorageAfter.toDays() + 90) {
-          throw new Error([
+          throw new UnscopedValidationError([
             '\'deleteAfter\' must at least 90 days later than corresponding \'moveToColdStorageAfter\'',
             `received 'deleteAfter: ${copyAction.deleteAfter.toDays()}' and 'moveToColdStorageAfter: ${copyAction.moveToColdStorageAfter.toDays()}'`,
           ].join('\n'));
diff --git a/packages/aws-cdk-lib/aws-backup/lib/vault.ts b/packages/aws-cdk-lib/aws-backup/lib/vault.ts

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`import { ScalingInterval } from './types';`
	`2`	`+import { UnscopedValidationError } from '../../core';`
`2`	`3`
`3`	`4`	`export interface CompleteScalingInterval {`
`4`	`5`	`readonly lower: number;`
`@@ -30,12 +31,12 @@ export function normalizeIntervals(intervals: ScalingInterval[], changesAreAbsol`
`30`	`31`	`*/`
`31`	`32`	`function orderAndCompleteIntervals(intervals: ScalingInterval[]): CompleteScalingInterval[] {`
`32`	`33`	`if (intervals.length < 2) {`
`33`		`- throw new Error('Require at least 2 intervals');`
	`34`	`+ throw new UnscopedValidationError('Require at least 2 intervals');`
`34`	`35`	`}`
`35`	`36`
`36`	`37`	`for (const interval of intervals) {`
`37`	`38`	`if (interval.lower === undefined && interval.upper === undefined) {`
`38`		- throw new Error(`Must supply at least one of 'upper' or 'lower', got: ${JSON.stringify(interval)}`);
	`39`	+ throw new UnscopedValidationError(`Must supply at least one of 'upper' or 'lower', got: ${JSON.stringify(interval)}`);
`39`	`40`	`}`
`40`	`41`	`}`
`41`	`42`
`@@ -55,7 +56,7 @@ function orderAndCompleteIntervals(intervals: ScalingInterval[]): CompleteScalin`
`55`	`56`	`if (intervals[lastIndex].upper === undefined) { intervals[lastIndex] = { ...intervals[lastIndex], upper: Infinity }; }`
`56`	`57`	`for (const interval of intervals) {`
`57`	`58`	`if (interval.lower === undefined \|\| interval.upper === undefined) {`
`58`		- throw new Error(`Could not determine the lower and upper bounds for ${JSON.stringify(interval)}`);
	`59`	+ throw new UnscopedValidationError(`Could not determine the lower and upper bounds for ${JSON.stringify(interval)}`);
`59`	`60`	`}`
`60`	`61`	`}`
`61`	`62`
`@@ -64,7 +65,7 @@ function orderAndCompleteIntervals(intervals: ScalingInterval[]): CompleteScalin`
`64`	`65`	`// Validate that we have nonoverlapping intervals now.`
`65`	`66`	`for (let i = 0; i < completeIntervals.length - 1; i++) {`
`66`	`67`	`if (overlap(completeIntervals[i], completeIntervals[i + 1])) {`
`67`		- throw new Error(`Two intervals overlap: ${JSON.stringify(completeIntervals[i])} and ${JSON.stringify(completeIntervals[i + 1])}`);
	`68`	+ throw new UnscopedValidationError(`Two intervals overlap: ${JSON.stringify(completeIntervals[i])} and ${JSON.stringify(completeIntervals[i + 1])}`);
`68`	`69`	`}`
`69`	`70`	`}`
`70`	`71`
`@@ -148,7 +149,7 @@ function combineUndefineds(intervals: CompleteScalingInterval[]) {`
`148`	`149`	`function validateAtMostOneUndefined(intervals: CompleteScalingInterval[]) {`
`149`	`150`	`const undef = intervals.filter(x => x.change === undefined);`
`150`	`151`	`if (undef.length > 1) {`
`151`		- throw new Error(`Can have at most one no-change interval, got ${JSON.stringify(undef)}`);
	`152`	+ throw new UnscopedValidationError(`Can have at most one no-change interval, got ${JSON.stringify(undef)}`);
`152`	`153`	`}`
`153`	`154`	`}`
`154`	`155`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ import { IAutoScalingGroup } from './auto-scaling-group';`
`3`	`3`	`import { AdjustmentType, MetricAggregationType, StepScalingAction } from './step-scaling-action';`
`4`	`4`	`import { findAlarmThresholds, normalizeIntervals } from '../../aws-autoscaling-common';`
`5`	`5`	`import * as cloudwatch from '../../aws-cloudwatch';`
`6`		`-import { Duration, Token } from '../../core';`
	`6`	`+import { Duration, Token, ValidationError } from '../../core';`
`7`	`7`
`8`	`8`	`export interface BasicStepScalingPolicyProps {`
`9`	`9`	`/**`
`@@ -112,28 +112,28 @@ export class StepScalingPolicy extends Construct {`
`112`	`112`	`super(scope, id);`
`113`	`113`
`114`	`114`	`if (props.scalingSteps.length < 2) {`
`115`		`- throw new Error('You must supply at least 2 intervals for autoscaling');`
	`115`	`+ throw new ValidationError('You must supply at least 2 intervals for autoscaling', this);`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`if (props.scalingSteps.length > 40) {`
`119`		- throw new Error(`'scalingSteps' can have at most 40 steps, got ${props.scalingSteps.length}`);
	`119`	+ throw new ValidationError(`'scalingSteps' can have at most 40 steps, got ${props.scalingSteps.length}`, this);
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`if (props.evaluationPeriods !== undefined && !Token.isUnresolved(props.evaluationPeriods) && props.evaluationPeriods < 1) {`
`123`		- throw new Error(`evaluationPeriods cannot be less than 1, got: ${props.evaluationPeriods}`);
	`123`	+ throw new ValidationError(`evaluationPeriods cannot be less than 1, got: ${props.evaluationPeriods}`, this);
`124`	`124`	`}`
`125`	`125`	`if (props.datapointsToAlarm !== undefined) {`
`126`	`126`	`if (props.evaluationPeriods === undefined) {`
`127`		`- throw new Error('evaluationPeriods must be set if datapointsToAlarm is set');`
	`127`	`+ throw new ValidationError('evaluationPeriods must be set if datapointsToAlarm is set', this);`
`128`	`128`	`}`
`129`	`129`	`if (!Token.isUnresolved(props.datapointsToAlarm) && props.datapointsToAlarm < 1) {`
`130`		- throw new Error(`datapointsToAlarm cannot be less than 1, got: ${props.datapointsToAlarm}`);
	`130`	+ throw new ValidationError(`datapointsToAlarm cannot be less than 1, got: ${props.datapointsToAlarm}`, this);
`131`	`131`	`}`
`132`	`132`	`if (!Token.isUnresolved(props.datapointsToAlarm)`
`133`	`133`	`&& !Token.isUnresolved(props.evaluationPeriods)`
`134`	`134`	`&& props.evaluationPeriods < props.datapointsToAlarm`
`135`	`135`	`) {`
`136`		- throw new Error(`datapointsToAlarm must be less than or equal to evaluationPeriods, got datapointsToAlarm: ${props.datapointsToAlarm}, evaluationPeriods: ${props.evaluationPeriods}`);
	`136`	+ throw new ValidationError(`datapointsToAlarm must be less than or equal to evaluationPeriods, got datapointsToAlarm: ${props.datapointsToAlarm}, evaluationPeriods: ${props.evaluationPeriods}`, this);
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`