terraconstructs 0.0.22 → 0.0.24

package/lib/aws/compute/scalable-target.d.ts

@@ -0,0 +1,197 @@
+import { appautoscalingScheduledAction } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { Schedule } from "./schedule";
+import { BasicStepScalingPolicyProps, StepScalingPolicy } from "./step-scaling-policy";
+import { BasicTargetTrackingScalingPolicyProps, TargetTrackingScalingPolicy } from "./target-tracking-scaling-policy";
+import { TimeZone } from "../../time-zone";
+import { AwsConstructBase, AwsConstructProps, IAwsConstruct } from "../aws-construct";
+import * as iam from "../iam";
+/**
+ * Represents a Application Auto Scaling Scalable Target
+ */
+export interface IScalableTarget extends IAwsConstruct {
+    /**
+     * The ID of the Scalable Target.
+     * This is typically in the format: service-namespace/resource-id/scalable-dimension
+     * @attribute
+     */
+    readonly scalableTargetId: string;
+    /**
+     * The IAM role that allows Application Auto Scaling to modify your scalable target.
+     */
+    readonly role?: iam.IRole;
+    /**
+     * The resource identifier to associate with this scalable target.
+     */
+    readonly resourceId: string;
+    /**
+     * The scalable dimension that's associated with the scalable target.
+     */
+    readonly scalableDimension: string;
+    /**
+     * The namespace of the AWS service that provides the resource.
+     */
+    readonly serviceNamespace: ServiceNamespace;
+    /**
+     * Add a policy statement to the role's policy document.
+     * @param statement The policy statement to add
+     */
+    addToRolePolicy(statement: iam.PolicyStatement): void;
+    /**
+     * Scale out or in based on time.
+     * @param id The ID of the scheduled action
+     * @param action The scaling schedule
+     */
+    scaleOnSchedule(id: string, action: ScalingSchedule): appautoscalingScheduledAction.AppautoscalingScheduledAction;
+    /**
+     * Scale out or in, in response to a metric.
+     * @param id The ID of the scaling policy
+     * @param props The properties for the step scaling policy
+     */
+    scaleOnMetric(id: string, props: BasicStepScalingPolicyProps): StepScalingPolicy;
+    /**
+     * Scale out or in in order to keep a metric around a target value.
+     * @param id The ID of the scaling policy
+     * @param props The properties for the target tracking scaling policy
+     */
+    scaleToTrackMetric(id: string, props: BasicTargetTrackingScalingPolicyProps): TargetTrackingScalingPolicy;
+}
+/**
+ * Properties for a scalable target
+ */
+export interface ScalableTargetProps extends AwsConstructProps {
+    /**
+     * The minimum value that Application Auto Scaling can use to scale a target during a scaling activity.
+     */
+    readonly minCapacity: number;
+    /**
+     * The maximum value that Application Auto Scaling can use to scale a target during a scaling activity.
+     */
+    readonly maxCapacity: number;
+    /**
+     * Role that allows Application Auto Scaling to modify your scalable target.
+     *
+     * @default A role is automatically created
+     */
+    readonly role?: iam.IRole;
+    /**
+     * The resource identifier to associate with this scalable target.
+     *
+     * This string consists of the resource type and unique identifier.
+     *
+     * Example value: `service/ecsStack-MyECSCluster-AB12CDE3F4GH/ecsStack-MyECSService-AB12CDE3F4GH`
+     *
+     * @see https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html
+     */
+    readonly resourceId: string;
+    /**
+     * The scalable dimension that's associated with the scalable target.
+     *
+     * Specify the service namespace, resource type, and scaling property.
+     *
+     * Example value: `ecs:service:DesiredCount`
+     * @see https://docs.aws.amazon.com/autoscaling/application/APIReference/API_ScalingPolicy.html
+     */
+    readonly scalableDimension: string;
+    /**
+     * The namespace of the AWS service that provides the resource or
+     * custom-resource for a resource provided by your own application or
+     * service.
+     *
+     * For valid AWS service namespace values, see the RegisterScalableTarget
+     * action in the Application Auto Scaling API Reference.
+     *
+     * @see https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html
+     */
+    readonly serviceNamespace: ServiceNamespace;
+}
+/**
+ * Define a scalable target
+ *
+ * @resource aws_appautoscaling_target
+ */
+export declare class ScalableTarget extends AwsConstructBase implements IScalableTarget {
+    static fromScalableTargetId(scope: Construct, id: string, scalableTargetId: string): IScalableTarget;
+    readonly scalableTargetId: string;
+    readonly role?: iam.IRole;
+    readonly resourceId: string;
+    readonly scalableDimension: string;
+    readonly serviceNamespace: ServiceNamespace;
+    private readonly targetResource;
+    constructor(scope: Construct, id: string, props: ScalableTargetProps);
+    get outputs(): Record<string, any>;
+    addToRolePolicy(statement: iam.PolicyStatement): void;
+    scaleOnSchedule(scheduleId: string, action: ScalingSchedule): appautoscalingScheduledAction.AppautoscalingScheduledAction;
+    scaleOnMetric(policyId: string, props: BasicStepScalingPolicyProps): StepScalingPolicy;
+    scaleToTrackMetric(policyId: string, props: BasicTargetTrackingScalingPolicyProps): TargetTrackingScalingPolicy;
+}
+/**
+ * A scheduled scaling action
+ */
+export interface ScalingSchedule {
+    /**
+     * When to perform this action.
+     */
+    readonly schedule: Schedule;
+    /**
+     * When this scheduled action becomes active.
+     *
+     * @default The rule is activate immediately
+     */
+    readonly startTime?: Date;
+    /**
+     * When this scheduled action expires.
+     *
+     * @default The rule never expires.
+     */
+    readonly endTime?: Date;
+    /**
+     * The new minimum capacity.
+     *
+     * During the scheduled time, if the current capacity is below the minimum
+     * capacity, Application Auto Scaling scales out to the minimum capacity.
+     *
+     * At least one of maxCapacity and minCapacity must be supplied.
+     *
+     * @default No new minimum capacity
+     */
+    readonly minCapacity?: number;
+    /**
+     * The new maximum capacity.
+     *
+     * During the scheduled time, the current capacity is above the maximum
+     * capacity, Application Auto Scaling scales in to the maximum capacity.
+     *
+     * At least one of maxCapacity and minCapacity must be supplied.
+     *
+     * @default No new maximum capacity
+     */
+    readonly maxCapacity?: number;
+    /**
+     * The time zone used when referring to the date and time of a scheduled action,
+     * when the scheduled action uses an at or cron expression.
+     *
+     * @default - UTC
+     */
+    readonly timeZone?: TimeZone;
+}
+/**
+ * The service that supports Application AutoScaling
+ */
+export declare enum ServiceNamespace {
+    ECS = "ecs",
+    ELASTIC_MAP_REDUCE = "elasticmapreduce",
+    EC2 = "ec2",
+    APPSTREAM = "appstream",
+    DYNAMODB = "dynamodb",
+    RDS = "rds",
+    SAGEMAKER = "sagemaker",
+    CUSTOM_RESOURCE = "custom-resource",
+    LAMBDA = "lambda",
+    COMPREHEND = "comprehend",
+    KAFKA = "kafka",
+    ELASTICACHE = "elasticache",
+    NEPTUNE = "neptune",
+    CASSANDRA = "cassandra",
+    WORKSPACES = "workspaces"
+}

package/lib/aws/compute/scalable-target.js

@@ -0,0 +1,168 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceNamespace = exports.ScalableTarget = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.168.0/packages/aws-cdk-lib/aws-applicationautoscaling/lib/scalable-target.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const step_scaling_policy_1 = require("./step-scaling-policy");
+const target_tracking_scaling_policy_1 = require("./target-tracking-scaling-policy");
+const token_1 = require("../../token");
+const aws_construct_1 = require("../aws-construct");
+const iam = require("../iam");
+/**
+ * Define a scalable target
+ *
+ * @resource aws_appautoscaling_target
+ */
+class ScalableTarget extends aws_construct_1.AwsConstructBase {
+    static fromScalableTargetId(scope, id, scalableTargetId) {
+        // Assuming scalableTargetId is in the format: serviceNamespace/resourceId/scalableDimension
+        const parts = scalableTargetId.split("/");
+        if (parts.length < 3) {
+            throw new Error("Invalid scalableTargetId format. Expected serviceNamespace/resourceId/scalableDimension");
+        }
+        const serviceNamespace = parts[0];
+        const scalableDimension = parts[parts.length - 1];
+        const resourceId = parts.slice(1, -1).join("/");
+        class Import extends aws_construct_1.AwsConstructBase {
+            constructor(s, i) {
+                super(s, i, {
+                    environmentFromArn: `arn:aws:application-autoscaling:${aws_construct_1.AwsConstructBase.isConstruct(s) ? s.env.region : "unknown"}:${aws_construct_1.AwsConstructBase.isConstruct(s) ? s.env.account : "unknown"}:scalable-target/${scalableTargetId}`,
+                });
+                this.scalableTargetId = scalableTargetId;
+                this.resourceId = resourceId;
+                this.scalableDimension = scalableDimension;
+                this.serviceNamespace = serviceNamespace;
+                // Role is not directly importable with just the target ID, it would need to be imported separately or ARN provided.
+                // For simplicity, we'll represent it as an unmodifiable imported role placeholder.
+                this.role = iam.Role.fromRoleArn(this, "ImportedRole", "arn:aws:iam::unknown:role/unknownapplicationautoscalingrole", { mutable: false });
+            }
+            get outputs() {
+                return { scalableTargetId: this.scalableTargetId };
+            }
+            addToRolePolicy(_statement) {
+                throw new Error("Cannot add to policy of an imported ScalableTarget role like this.");
+            }
+            scaleOnSchedule(_actionId, _action) {
+                throw new Error("Cannot add scheduled action to an imported ScalableTarget.");
+            }
+            scaleOnMetric(_policyId, _props) {
+                throw new Error("Cannot add step scaling policy to an imported ScalableTarget.");
+            }
+            scaleToTrackMetric(_policyId, _props) {
+                throw new Error("Cannot add target tracking policy to an imported ScalableTarget.");
+            }
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        (0, token_1.withResolved)(props.maxCapacity, (max) => {
+            if (max < 0) {
+                throw new Error(`maxCapacity cannot be negative, got: ${props.maxCapacity}`);
+            }
+        });
+        (0, token_1.withResolved)(props.minCapacity, (min) => {
+            if (min < 0) {
+                throw new Error(`minCapacity cannot be negative, got: ${props.minCapacity}`);
+            }
+        });
+        (0, token_1.withResolved)(props.minCapacity, props.maxCapacity, (min, max) => {
+            if (max < min) {
+                throw new Error(`minCapacity (${props.minCapacity}) should be lower than maxCapacity (${props.maxCapacity})`);
+            }
+        });
+        // For DynamoDB autoscaling, use service-linked roles when no explicit role is provided
+        // This allows Terraform to automatically manage the appropriate service-linked role
+        // rather than creating a custom IAM role that may have incorrect ARN format
+        this.role = props.role;
+        const targetConfig = {
+            maxCapacity: props.maxCapacity,
+            minCapacity: props.minCapacity,
+            resourceId: props.resourceId,
+            scalableDimension: props.scalableDimension,
+            serviceNamespace: props.serviceNamespace,
+        };
+        // Only include roleArn if a role is explicitly provided
+        // When omitted, Terraform will use appropriate service-linked roles
+        if (this.role) {
+            targetConfig.roleArn = this.role.roleArn;
+        }
+        this.targetResource = new provider_aws_1.appautoscalingTarget.AppautoscalingTarget(this, "Resource", targetConfig);
+        this.scalableTargetId = this.targetResource.id;
+        this.resourceId = props.resourceId;
+        this.scalableDimension = props.scalableDimension;
+        this.serviceNamespace = props.serviceNamespace;
+    }
+    get outputs() {
+        return {
+            scalableTargetId: this.scalableTargetId,
+            roleArn: this.role?.roleArn,
+        };
+    }
+    addToRolePolicy(statement) {
+        if (!this.role) {
+            throw new Error("Cannot add policy to role when using service-linked roles. " +
+                "Provide an explicit role in ScalableTargetProps if you need to add custom policies.");
+        }
+        this.role.addToPrincipalPolicy(statement);
+    }
+    scaleOnSchedule(scheduleId, action) {
+        if (action.minCapacity === undefined && action.maxCapacity === undefined) {
+            throw new Error(`You must supply at least one of minCapacity or maxCapacity, got ${JSON.stringify(action)}`);
+        }
+        action.schedule._bind(this);
+        return new provider_aws_1.appautoscalingScheduledAction.AppautoscalingScheduledAction(this, scheduleId, {
+            name: scheduleId,
+            serviceNamespace: this.serviceNamespace,
+            resourceId: this.resourceId,
+            scalableDimension: this.scalableDimension,
+            schedule: action.schedule.expressionString,
+            startTime: action.startTime?.toISOString(),
+            endTime: action.endTime?.toISOString(),
+            scalableTargetAction: {
+                maxCapacity: action.maxCapacity?.toString(),
+                minCapacity: action.minCapacity?.toString(),
+            },
+            timezone: action.timeZone?.timezoneName,
+        });
+    }
+    scaleOnMetric(policyId, props) {
+        return new step_scaling_policy_1.StepScalingPolicy(this, policyId, {
+            ...props,
+            scalingTarget: this,
+        });
+    }
+    scaleToTrackMetric(policyId, props) {
+        return new target_tracking_scaling_policy_1.TargetTrackingScalingPolicy(this, policyId, {
+            ...props,
+            scalingTarget: this,
+        });
+    }
+}
+exports.ScalableTarget = ScalableTarget;
+_a = JSII_RTTI_SYMBOL_1;
+ScalableTarget[_a] = { fqn: "terraconstructs.aws.compute.ScalableTarget", version: "0.0.24" };
+/**
+ * The service that supports Application AutoScaling
+ */
+var ServiceNamespace;
+(function (ServiceNamespace) {
+    ServiceNamespace["ECS"] = "ecs";
+    ServiceNamespace["ELASTIC_MAP_REDUCE"] = "elasticmapreduce";
+    ServiceNamespace["EC2"] = "ec2";
+    ServiceNamespace["APPSTREAM"] = "appstream";
+    ServiceNamespace["DYNAMODB"] = "dynamodb";
+    ServiceNamespace["RDS"] = "rds";
+    ServiceNamespace["SAGEMAKER"] = "sagemaker";
+    ServiceNamespace["CUSTOM_RESOURCE"] = "custom-resource";
+    ServiceNamespace["LAMBDA"] = "lambda";
+    ServiceNamespace["COMPREHEND"] = "comprehend";
+    ServiceNamespace["KAFKA"] = "kafka";
+    ServiceNamespace["ELASTICACHE"] = "elasticache";
+    ServiceNamespace["NEPTUNE"] = "neptune";
+    ServiceNamespace["CASSANDRA"] = "cassandra";
+    ServiceNamespace["WORKSPACES"] = "workspaces";
+})(ServiceNamespace || (exports.ServiceNamespace = ServiceNamespace = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scalable-target.js","sourceRoot":"","sources":["../../../src/aws/compute/scalable-target.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.168.0/packages/aws-cdk-lib/aws-applicationautoscaling/lib/scalable-target.ts\n\nimport {\n  appautoscalingTarget,\n  appautoscalingScheduledAction,\n} from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { Schedule } from \"./schedule\";\nimport {\n  BasicStepScalingPolicyProps,\n  StepScalingPolicy,\n} from \"./step-scaling-policy\";\nimport {\n  BasicTargetTrackingScalingPolicyProps,\n  TargetTrackingScalingPolicy,\n} from \"./target-tracking-scaling-policy\";\nimport { TimeZone } from \"../../time-zone\";\nimport { withResolved } from \"../../token\";\nimport {\n  AwsConstructBase,\n  AwsConstructProps,\n  IAwsConstruct,\n} from \"../aws-construct\";\nimport * as iam from \"../iam\";\n\n/**\n * Represents a Application Auto Scaling Scalable Target\n */\nexport interface IScalableTarget extends IAwsConstruct {\n  /**\n   * The ID of the Scalable Target.\n   * This is typically in the format: service-namespace/resource-id/scalable-dimension\n   * @attribute\n   */\n  readonly scalableTargetId: string;\n\n  /**\n   * The IAM role that allows Application Auto Scaling to modify your scalable target.\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * The resource identifier to associate with this scalable target.\n   */\n  readonly resourceId: string;\n\n  /**\n   * The scalable dimension that's associated with the scalable target.\n   */\n  readonly scalableDimension: string;\n\n  /**\n   * The namespace of the AWS service that provides the resource.\n   */\n  readonly serviceNamespace: ServiceNamespace;\n\n  /**\n   * Add a policy statement to the role's policy document.\n   * @param statement The policy statement to add\n   */\n  addToRolePolicy(statement: iam.PolicyStatement): void;\n\n  /**\n   * Scale out or in based on time.\n   * @param id The ID of the scheduled action\n   * @param action The scaling schedule\n   */\n  scaleOnSchedule(\n    id: string,\n    action: ScalingSchedule,\n  ): appautoscalingScheduledAction.AppautoscalingScheduledAction;\n\n  /**\n   * Scale out or in, in response to a metric.\n   * @param id The ID of the scaling policy\n   * @param props The properties for the step scaling policy\n   */\n  scaleOnMetric(\n    id: string,\n    props: BasicStepScalingPolicyProps,\n  ): StepScalingPolicy;\n\n  /**\n   * Scale out or in in order to keep a metric around a target value.\n   * @param id The ID of the scaling policy\n   * @param props The properties for the target tracking scaling policy\n   */\n  scaleToTrackMetric(\n    id: string,\n    props: BasicTargetTrackingScalingPolicyProps,\n  ): TargetTrackingScalingPolicy;\n}\n\n/**\n * Properties for a scalable target\n */\nexport interface ScalableTargetProps extends AwsConstructProps {\n  /**\n   * The minimum value that Application Auto Scaling can use to scale a target during a scaling activity.\n   */\n  readonly minCapacity: number;\n\n  /**\n   * The maximum value that Application Auto Scaling can use to scale a target during a scaling activity.\n   */\n  readonly maxCapacity: number;\n\n  /**\n   * Role that allows Application Auto Scaling to modify your scalable target.\n   *\n   * @default A role is automatically created\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * The resource identifier to associate with this scalable target.\n   *\n   * This string consists of the resource type and unique identifier.\n   *\n   * Example value: `service/ecsStack-MyECSCluster-AB12CDE3F4GH/ecsStack-MyECSService-AB12CDE3F4GH`\n   *\n   * @see https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html\n   */\n  readonly resourceId: string;\n\n  /**\n   * The scalable dimension that's associated with the scalable target.\n   *\n   * Specify the service namespace, resource type, and scaling property.\n   *\n   * Example value: `ecs:service:DesiredCount`\n   * @see https://docs.aws.amazon.com/autoscaling/application/APIReference/API_ScalingPolicy.html\n   */\n  readonly scalableDimension: string;\n\n  /**\n   * The namespace of the AWS service that provides the resource or\n   * custom-resource for a resource provided by your own application or\n   * service.\n   *\n   * For valid AWS service namespace values, see the RegisterScalableTarget\n   * action in the Application Auto Scaling API Reference.\n   *\n   * @see https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html\n   */\n  readonly serviceNamespace: ServiceNamespace;\n}\n\n/**\n * Define a scalable target\n *\n * @resource aws_appautoscaling_target\n */\nexport class ScalableTarget\n  extends AwsConstructBase\n  implements IScalableTarget\n{\n  public static fromScalableTargetId(\n    scope: Construct,\n    id: string,\n    scalableTargetId: string,\n  ): IScalableTarget {\n    // Assuming scalableTargetId is in the format: serviceNamespace/resourceId/scalableDimension\n    const parts = scalableTargetId.split(\"/\");\n    if (parts.length < 3) {\n      throw new Error(\n        \"Invalid scalableTargetId format. Expected serviceNamespace/resourceId/scalableDimension\",\n      );\n    }\n    const serviceNamespace = parts[0] as ServiceNamespace;\n    const scalableDimension = parts[parts.length - 1];\n    const resourceId = parts.slice(1, -1).join(\"/\");\n\n    class Import extends AwsConstructBase implements IScalableTarget {\n      public readonly scalableTargetId = scalableTargetId;\n      public readonly role: iam.IRole;\n      public readonly resourceId = resourceId;\n      public readonly scalableDimension = scalableDimension;\n      public readonly serviceNamespace = serviceNamespace;\n\n      constructor(s: Construct, i: string) {\n        super(s, i, {\n          environmentFromArn: `arn:aws:application-autoscaling:${AwsConstructBase.isConstruct(s) ? (s as AwsConstructBase).env.region : \"unknown\"}:${AwsConstructBase.isConstruct(s) ? (s as AwsConstructBase).env.account : \"unknown\"}:scalable-target/${scalableTargetId}`,\n        });\n        // Role is not directly importable with just the target ID, it would need to be imported separately or ARN provided.\n        // For simplicity, we'll represent it as an unmodifiable imported role placeholder.\n        this.role = iam.Role.fromRoleArn(\n          this,\n          \"ImportedRole\",\n          \"arn:aws:iam::unknown:role/unknownapplicationautoscalingrole\",\n          { mutable: false },\n        );\n      }\n\n      public get outputs(): Record<string, any> {\n        return { scalableTargetId: this.scalableTargetId };\n      }\n\n      public addToRolePolicy(_statement: iam.PolicyStatement): void {\n        throw new Error(\n          \"Cannot add to policy of an imported ScalableTarget role like this.\",\n        );\n      }\n\n      public scaleOnSchedule(\n        _actionId: string,\n        _action: ScalingSchedule,\n      ): appautoscalingScheduledAction.AppautoscalingScheduledAction {\n        throw new Error(\n          \"Cannot add scheduled action to an imported ScalableTarget.\",\n        );\n      }\n\n      public scaleOnMetric(\n        _policyId: string,\n        _props: BasicStepScalingPolicyProps,\n      ): StepScalingPolicy {\n        throw new Error(\n          \"Cannot add step scaling policy to an imported ScalableTarget.\",\n        );\n      }\n\n      public scaleToTrackMetric(\n        _policyId: string,\n        _props: BasicTargetTrackingScalingPolicyProps,\n      ): TargetTrackingScalingPolicy {\n        throw new Error(\n          \"Cannot add target tracking policy to an imported ScalableTarget.\",\n        );\n      }\n    }\n    return new Import(scope, id);\n  }\n\n  public readonly scalableTargetId: string;\n  public readonly role?: iam.IRole;\n  public readonly resourceId: string;\n  public readonly scalableDimension: string;\n  public readonly serviceNamespace: ServiceNamespace;\n\n  private readonly targetResource: appautoscalingTarget.AppautoscalingTarget;\n\n  constructor(scope: Construct, id: string, props: ScalableTargetProps) {\n    super(scope, id, props);\n\n    withResolved(props.maxCapacity, (max) => {\n      if (max < 0) {\n        throw new Error(\n          `maxCapacity cannot be negative, got: ${props.maxCapacity}`,\n        );\n      }\n    });\n\n    withResolved(props.minCapacity, (min) => {\n      if (min < 0) {\n        throw new Error(\n          `minCapacity cannot be negative, got: ${props.minCapacity}`,\n        );\n      }\n    });\n\n    withResolved(props.minCapacity, props.maxCapacity, (min, max) => {\n      if (max < min) {\n        throw new Error(\n          `minCapacity (${props.minCapacity}) should be lower than maxCapacity (${props.maxCapacity})`,\n        );\n      }\n    });\n\n    // For DynamoDB autoscaling, use service-linked roles when no explicit role is provided\n    // This allows Terraform to automatically manage the appropriate service-linked role\n    // rather than creating a custom IAM role that may have incorrect ARN format\n    this.role = props.role;\n\n    const targetConfig: any = {\n      maxCapacity: props.maxCapacity,\n      minCapacity: props.minCapacity,\n      resourceId: props.resourceId,\n      scalableDimension: props.scalableDimension,\n      serviceNamespace: props.serviceNamespace,\n    };\n\n    // Only include roleArn if a role is explicitly provided\n    // When omitted, Terraform will use appropriate service-linked roles\n    if (this.role) {\n      targetConfig.roleArn = this.role.roleArn;\n    }\n\n    this.targetResource = new appautoscalingTarget.AppautoscalingTarget(\n      this,\n      \"Resource\",\n      targetConfig,\n    );\n\n    this.scalableTargetId = this.targetResource.id;\n    this.resourceId = props.resourceId;\n    this.scalableDimension = props.scalableDimension;\n    this.serviceNamespace = props.serviceNamespace;\n  }\n\n  public get outputs(): Record<string, any> {\n    return {\n      scalableTargetId: this.scalableTargetId,\n      roleArn: this.role?.roleArn,\n    };\n  }\n\n  public addToRolePolicy(statement: iam.PolicyStatement) {\n    if (!this.role) {\n      throw new Error(\n        \"Cannot add policy to role when using service-linked roles. \" +\n          \"Provide an explicit role in ScalableTargetProps if you need to add custom policies.\",\n      );\n    }\n    this.role.addToPrincipalPolicy(statement);\n  }\n\n  public scaleOnSchedule(\n    scheduleId: string,\n    action: ScalingSchedule,\n  ): appautoscalingScheduledAction.AppautoscalingScheduledAction {\n    if (action.minCapacity === undefined && action.maxCapacity === undefined) {\n      throw new Error(\n        `You must supply at least one of minCapacity or maxCapacity, got ${JSON.stringify(action)}`,\n      );\n    }\n\n    action.schedule._bind(this);\n\n    return new appautoscalingScheduledAction.AppautoscalingScheduledAction(\n      this,\n      scheduleId,\n      {\n        name: scheduleId,\n        serviceNamespace: this.serviceNamespace,\n        resourceId: this.resourceId,\n        scalableDimension: this.scalableDimension,\n        schedule: action.schedule.expressionString,\n        startTime: action.startTime?.toISOString(),\n        endTime: action.endTime?.toISOString(),\n        scalableTargetAction: {\n          maxCapacity: action.maxCapacity?.toString(),\n          minCapacity: action.minCapacity?.toString(),\n        },\n        timezone: action.timeZone?.timezoneName,\n      },\n    );\n  }\n\n  public scaleOnMetric(\n    policyId: string,\n    props: BasicStepScalingPolicyProps,\n  ): StepScalingPolicy {\n    return new StepScalingPolicy(this, policyId, {\n      ...props,\n      scalingTarget: this,\n    });\n  }\n\n  public scaleToTrackMetric(\n    policyId: string,\n    props: BasicTargetTrackingScalingPolicyProps,\n  ): TargetTrackingScalingPolicy {\n    return new TargetTrackingScalingPolicy(this, policyId, {\n      ...props,\n      scalingTarget: this,\n    });\n  }\n}\n\n/**\n * A scheduled scaling action\n */\nexport interface ScalingSchedule {\n  /**\n   * When to perform this action.\n   */\n  readonly schedule: Schedule;\n\n  /**\n   * When this scheduled action becomes active.\n   *\n   * @default The rule is activate immediately\n   */\n  readonly startTime?: Date;\n\n  /**\n   * When this scheduled action expires.\n   *\n   * @default The rule never expires.\n   */\n  readonly endTime?: Date;\n\n  /**\n   * The new minimum capacity.\n   *\n   * During the scheduled time, if the current capacity is below the minimum\n   * capacity, Application Auto Scaling scales out to the minimum capacity.\n   *\n   * At least one of maxCapacity and minCapacity must be supplied.\n   *\n   * @default No new minimum capacity\n   */\n  readonly minCapacity?: number;\n\n  /**\n   * The new maximum capacity.\n   *\n   * During the scheduled time, the current capacity is above the maximum\n   * capacity, Application Auto Scaling scales in to the maximum capacity.\n   *\n   * At least one of maxCapacity and minCapacity must be supplied.\n   *\n   * @default No new maximum capacity\n   */\n  readonly maxCapacity?: number;\n\n  /**\n   * The time zone used when referring to the date and time of a scheduled action,\n   * when the scheduled action uses an at or cron expression.\n   *\n   * @default - UTC\n   */\n  readonly timeZone?: TimeZone;\n}\n\n/**\n * The service that supports Application AutoScaling\n */\nexport enum ServiceNamespace {\n  ECS = \"ecs\",\n  ELASTIC_MAP_REDUCE = \"elasticmapreduce\",\n  EC2 = \"ec2\",\n  APPSTREAM = \"appstream\",\n  DYNAMODB = \"dynamodb\",\n  RDS = \"rds\",\n  SAGEMAKER = \"sagemaker\",\n  CUSTOM_RESOURCE = \"custom-resource\",\n  LAMBDA = \"lambda\",\n  COMPREHEND = \"comprehend\",\n  KAFKA = \"kafka\",\n  ELASTICACHE = \"elasticache\",\n  NEPTUNE = \"neptune\",\n  CASSANDRA = \"cassandra\",\n  WORKSPACES = \"workspaces\",\n}\n"]}

package/lib/aws/compute/schedule.d.ts

@@ -0,0 +1,81 @@
+import { Construct } from "constructs";
+import { Duration } from "../../duration";
+/**
+ * Schedule for scheduled scaling actions
+ */
+export declare abstract class Schedule {
+    /**
+     * Construct a schedule from a literal schedule expression
+     *
+     * @param expression The expression to use. Must be in a format that Application AutoScaling will recognize
+     */
+    static expression(expression: string): Schedule;
+    /**
+     * Construct a schedule from an interval and a time unit
+     */
+    static rate(duration: Duration): Schedule;
+    /**
+     * Construct a Schedule from a moment in time
+     */
+    static at(moment: Date): Schedule;
+    /**
+     * Create a schedule from a set of cron fields
+     */
+    static cron(options: CronOptions): Schedule;
+    /**
+     * Retrieve the expression for this schedule
+     */
+    abstract readonly expressionString: string;
+    protected constructor();
+    /**
+     *
+     * @internal
+     */
+    abstract _bind(scope: Construct): void;
+}
+/**
+ * Options to configure a cron expression
+ *
+ * All fields are strings so you can use complex expressions. Absence of
+ * a field implies '*' or '?', whichever one is appropriate.
+ *
+ * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions
+ */
+export interface CronOptions {
+    /**
+     * The minute to run this rule at
+     *
+     * @default - Every minute
+     */
+    readonly minute?: string;
+    /**
+     * The hour to run this rule at
+     *
+     * @default - Every hour
+     */
+    readonly hour?: string;
+    /**
+     * The day of the month to run this rule at
+     *
+     * @default - Every day of the month
+     */
+    readonly day?: string;
+    /**
+     * The month to run this rule at
+     *
+     * @default - Every month
+     */
+    readonly month?: string;
+    /**
+     * The year to run this rule at
+     *
+     * @default - Every year
+     */
+    readonly year?: string;
+    /**
+     * The day of the week to run this rule at
+     *
+     * @default - Any day of the week
+     */
+    readonly weekDay?: string;
+}

package/lib/aws/compute/schedule.js

@@ -0,0 +1,145 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schedule = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.168.0/packages/aws-cdk-lib/aws-applicationautoscaling/lib/schedule.ts
+const cdktf_1 = require("cdktf");
+// TODO Adupt ValidationError is available, otherwise use standard Error
+// - https://github.com/aws/aws-cdk/pull/33382/
+// - https://github.com/aws/aws-cdk/pull/33045
+// import { UnscopedValidationError } from "../../errors";
+/**
+ * Schedule for scheduled scaling actions
+ */
+class Schedule {
+    /**
+     * Construct a schedule from a literal schedule expression
+     *
+     * @param expression The expression to use. Must be in a format that Application AutoScaling will recognize
+     */
+    static expression(expression) {
+        return new LiteralSchedule(expression);
+    }
+    /**
+     * Construct a schedule from an interval and a time unit
+     */
+    static rate(duration) {
+        if (duration.isUnresolved()) {
+            const validDurationUnit = [
+                "minute",
+                "minutes",
+                "hour",
+                "hours",
+                "day",
+                "days",
+            ];
+            if (!validDurationUnit.includes(duration.unitLabel())) {
+                // throw new UnscopedValidationError(
+                throw new Error("Allowed units for scheduling are: 'minute', 'minutes', 'hour', 'hours', 'day' or 'days'");
+            }
+            return new LiteralSchedule(`rate(${duration.formatTokenToNumber()})`);
+        }
+        if (duration.toSeconds() === 0) {
+            // throw new UnscopedValidationError(
+            throw new Error("Duration cannot be 0");
+        }
+        let rate = maybeRate(duration.toDays({ integral: false }), "day");
+        if (rate === undefined) {
+            rate = maybeRate(duration.toHours({ integral: false }), "hour");
+        }
+        if (rate === undefined) {
+            rate = makeRate(duration.toMinutes({ integral: true }), "minute");
+        }
+        return new LiteralSchedule(rate);
+    }
+    /**
+     * Construct a Schedule from a moment in time
+     */
+    static at(moment) {
+        return new LiteralSchedule(`at(${formatISO(moment)})`);
+    }
+    /**
+     * Create a schedule from a set of cron fields
+     */
+    static cron(options) {
+        if (options.weekDay !== undefined && options.day !== undefined) {
+            // throw new UnscopedValidationError(
+            throw new Error("Cannot supply both 'day' and 'weekDay', use at most one");
+        }
+        const minute = fallback(options.minute, "*");
+        const hour = fallback(options.hour, "*");
+        const month = fallback(options.month, "*");
+        const year = fallback(options.year, "*");
+        // Weekday defaults to '?' if not supplied. If it is supplied, day must become '?'
+        const day = fallback(options.day, options.weekDay !== undefined ? "?" : "*");
+        const weekDay = fallback(options.weekDay, "?");
+        return new (class extends Schedule {
+            constructor() {
+                super(...arguments);
+                this.expressionString = `cron(${minute} ${hour} ${day} ${month} ${weekDay} ${year})`;
+            }
+            _bind(scope) {
+                if (!options.minute) {
+                    // "@aws-cdk/aws-applicationautoscaling:defaultRunEveryMinute",
+                    cdktf_1.Annotations.of(scope).addWarning("cron: If you don't pass 'minute', by default the event runs every minute. Pass 'minute: '*'' if that's what you intend, or 'minute: 0' to run once per hour instead.");
+                }
+                return new LiteralSchedule(this.expressionString);
+            }
+        })();
+    }
+    constructor() { }
+}
+exports.Schedule = Schedule;
+_a = JSII_RTTI_SYMBOL_1;
+Schedule[_a] = { fqn: "terraconstructs.aws.compute.Schedule", version: "0.0.24" };
+class LiteralSchedule extends Schedule {
+    constructor(expressionString) {
+        super();
+        this.expressionString = expressionString;
+    }
+    _bind() { }
+}
+function fallback(x, def) {
+    return x === undefined ? def : x;
+}
+function formatISO(date) {
+    if (!date) {
+        return undefined;
+    }
+    return (date.getUTCFullYear() +
+        "-" +
+        pad(date.getUTCMonth() + 1) +
+        "-" +
+        pad(date.getUTCDate()) +
+        "T" +
+        pad(date.getUTCHours()) +
+        ":" +
+        pad(date.getUTCMinutes()) +
+        ":" +
+        pad(date.getUTCSeconds()));
+    function pad(num) {
+        if (num < 10) {
+            return "0" + num;
+        }
+        return num;
+    }
+}
+/**
+ * Return the rate if the rate is whole number
+ */
+function maybeRate(interval, singular) {
+    if (interval === 0 || !Number.isInteger(interval)) {
+        return undefined;
+    }
+    return makeRate(interval, singular);
+}
+/**
+ * Return 'rate(${interval} ${singular}(s))` for the interval
+ */
+function makeRate(interval, singular) {
+    return interval === 1
+        ? `rate(1 ${singular})`
+        : `rate(${interval} ${singular}s)`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schedule.js","sourceRoot":"","sources":["../../../src/aws/compute/schedule.ts"],"names":[],"mappings":";;;;;AAAA,+GAA+G;AAE/G,iCAAoC;AAGpC,wEAAwE;AACxE,+CAA+C;AAC/C,8CAA8C;AAC9C,0DAA0D;AAE1D;;GAEG;AACH,MAAsB,QAAQ;IAC5B;;;;OAIG;IACI,MAAM,CAAC,UAAU,CAAC,UAAkB;QACzC,OAAO,IAAI,eAAe,CAAC,UAAU,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,IAAI,CAAC,QAAkB;QACnC,IAAI,QAAQ,CAAC,YAAY,EAAE,EAAE,CAAC;YAC5B,MAAM,iBAAiB,GAAG;gBACxB,QAAQ;gBACR,SAAS;gBACT,MAAM;gBACN,OAAO;gBACP,KAAK;gBACL,MAAM;aACP,CAAC;YACF,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,EAAE,CAAC;gBACtD,qCAAqC;gBACrC,MAAM,IAAI,KAAK,CACb,yFAAyF,CAC1F,CAAC;YACJ,CAAC;YACD,OAAO,IAAI,eAAe,CAAC,QAAQ,QAAQ,CAAC,mBAAmB,EAAE,GAAG,CAAC,CAAC;QACxE,CAAC;QACD,IAAI,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC;YAC/B,qCAAqC;YACrC,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;QAC1C,CAAC;QAED,IAAI,IAAI,GAAG,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;QAClE,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,IAAI,GAAG,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;QAClE,CAAC;QACD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;QACpE,CAAC;QACD,OAAO,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,EAAE,CAAC,MAAY;QAC3B,OAAO,IAAI,eAAe,CAAC,MAAM,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACzD,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,IAAI,CAAC,OAAoB;QACrC,IAAI,OAAO,CAAC,OAAO,KAAK,SAAS,IAAI,OAAO,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;YAC/D,qCAAqC;YACrC,MAAM,IAAI,KAAK,CACb,yDAAyD,CAC1D,CAAC;QACJ,CAAC;QAED,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC7C,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QACzC,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAC3C,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAEzC,kFAAkF;QAClF,MAAM,GAAG,GAAG,QAAQ,CAClB,OAAO,CAAC,GAAG,EACX,OAAO,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAC1C,CAAC;QACF,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QAE/C,OAAO,IAAI,CAAC,KAAM,SAAQ,QAAQ;YAAtB;;gBACM,qBAAgB,GAAW,QAAQ,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,KAAK,IAAI,OAAO,IAAI,IAAI,GAAG,CAAC;YAU1G,CAAC;YATQ,KAAK,CAAC,KAAgB;gBAC3B,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;oBACpB,+DAA+D;oBAC/D,mBAAW,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,UAAU,CAC9B,sKAAsK,CACvK,CAAC;gBACJ,CAAC;gBACD,OAAO,IAAI,eAAe,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;YACpD,CAAC;SACF,CAAC,EAAE,CAAC;IACP,CAAC;IAOD,gBAAyB,CAAC;;AA/F5B,4BAsGC;;;AAsDD,MAAM,eAAgB,SAAQ,QAAQ;IACpC,YAA4B,gBAAwB;QAClD,KAAK,EAAE,CAAC;QADkB,qBAAgB,GAAhB,gBAAgB,CAAQ;IAEpD,CAAC;IAEM,KAAK,KAAI,CAAC;CAClB;AAED,SAAS,QAAQ,CAAI,CAAgB,EAAE,GAAM;IAC3C,OAAO,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,SAAS,CAAC,IAAW;IAC5B,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,CACL,IAAI,CAAC,cAAc,EAAE;QACrB,GAAG;QACH,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;QAC3B,GAAG;QACH,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;QACtB,GAAG;QACH,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;QACvB,GAAG;QACH,GAAG,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;QACzB,GAAG;QACH,GAAG,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAC1B,CAAC;IAEF,SAAS,GAAG,CAAC,GAAW;QACtB,IAAI,GAAG,GAAG,EAAE,EAAE,CAAC;YACb,OAAO,GAAG,GAAG,GAAG,CAAC;QACnB,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,SAAS,CAAC,QAAgB,EAAE,QAAgB;IACnD,IAAI,QAAQ,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;QAClD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AACtC,CAAC;AAED;;GAEG;AACH,SAAS,QAAQ,CAAC,QAAgB,EAAE,QAAgB;IAClD,OAAO,QAAQ,KAAK,CAAC;QACnB,CAAC,CAAC,UAAU,QAAQ,GAAG;QACvB,CAAC,CAAC,QAAQ,QAAQ,IAAI,QAAQ,IAAI,CAAC;AACvC,CAAC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.168.0/packages/aws-cdk-lib/aws-applicationautoscaling/lib/schedule.ts\n\nimport { Annotations } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Duration } from \"../../duration\";\n// TODO Adupt ValidationError is available, otherwise use standard Error\n// - https://github.com/aws/aws-cdk/pull/33382/\n// - https://github.com/aws/aws-cdk/pull/33045\n// import { UnscopedValidationError } from \"../../errors\";\n\n/**\n * Schedule for scheduled scaling actions\n */\nexport abstract class Schedule {\n  /**\n   * Construct a schedule from a literal schedule expression\n   *\n   * @param expression The expression to use. Must be in a format that Application AutoScaling will recognize\n   */\n  public static expression(expression: string): Schedule {\n    return new LiteralSchedule(expression);\n  }\n\n  /**\n   * Construct a schedule from an interval and a time unit\n   */\n  public static rate(duration: Duration): Schedule {\n    if (duration.isUnresolved()) {\n      const validDurationUnit = [\n        \"minute\",\n        \"minutes\",\n        \"hour\",\n        \"hours\",\n        \"day\",\n        \"days\",\n      ];\n      if (!validDurationUnit.includes(duration.unitLabel())) {\n        // throw new UnscopedValidationError(\n        throw new Error(\n          \"Allowed units for scheduling are: 'minute', 'minutes', 'hour', 'hours', 'day' or 'days'\",\n        );\n      }\n      return new LiteralSchedule(`rate(${duration.formatTokenToNumber()})`);\n    }\n    if (duration.toSeconds() === 0) {\n      // throw new UnscopedValidationError(\n      throw new Error(\"Duration cannot be 0\");\n    }\n\n    let rate = maybeRate(duration.toDays({ integral: false }), \"day\");\n    if (rate === undefined) {\n      rate = maybeRate(duration.toHours({ integral: false }), \"hour\");\n    }\n    if (rate === undefined) {\n      rate = makeRate(duration.toMinutes({ integral: true }), \"minute\");\n    }\n    return new LiteralSchedule(rate);\n  }\n\n  /**\n   * Construct a Schedule from a moment in time\n   */\n  public static at(moment: Date): Schedule {\n    return new LiteralSchedule(`at(${formatISO(moment)})`);\n  }\n\n  /**\n   * Create a schedule from a set of cron fields\n   */\n  public static cron(options: CronOptions): Schedule {\n    if (options.weekDay !== undefined && options.day !== undefined) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        \"Cannot supply both 'day' and 'weekDay', use at most one\",\n      );\n    }\n\n    const minute = fallback(options.minute, \"*\");\n    const hour = fallback(options.hour, \"*\");\n    const month = fallback(options.month, \"*\");\n    const year = fallback(options.year, \"*\");\n\n    // Weekday defaults to '?' if not supplied. If it is supplied, day must become '?'\n    const day = fallback(\n      options.day,\n      options.weekDay !== undefined ? \"?\" : \"*\",\n    );\n    const weekDay = fallback(options.weekDay, \"?\");\n\n    return new (class extends Schedule {\n      public readonly expressionString: string = `cron(${minute} ${hour} ${day} ${month} ${weekDay} ${year})`;\n      public _bind(scope: Construct) {\n        if (!options.minute) {\n          // \"@aws-cdk/aws-applicationautoscaling:defaultRunEveryMinute\",\n          Annotations.of(scope).addWarning(\n            \"cron: If you don't pass 'minute', by default the event runs every minute. Pass 'minute: '*'' if that's what you intend, or 'minute: 0' to run once per hour instead.\",\n          );\n        }\n        return new LiteralSchedule(this.expressionString);\n      }\n    })();\n  }\n\n  /**\n   * Retrieve the expression for this schedule\n   */\n  public abstract readonly expressionString: string;\n\n  protected constructor() {}\n\n  /**\n   *\n   * @internal\n   */\n  public abstract _bind(scope: Construct): void;\n}\n\n/**\n * Options to configure a cron expression\n *\n * All fields are strings so you can use complex expressions. Absence of\n * a field implies '*' or '?', whichever one is appropriate.\n *\n * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions\n */\nexport interface CronOptions {\n  /**\n   * The minute to run this rule at\n   *\n   * @default - Every minute\n   */\n  readonly minute?: string;\n\n  /**\n   * The hour to run this rule at\n   *\n   * @default - Every hour\n   */\n  readonly hour?: string;\n\n  /**\n   * The day of the month to run this rule at\n   *\n   * @default - Every day of the month\n   */\n  readonly day?: string;\n\n  /**\n   * The month to run this rule at\n   *\n   * @default - Every month\n   */\n  readonly month?: string;\n\n  /**\n   * The year to run this rule at\n   *\n   * @default - Every year\n   */\n  readonly year?: string;\n\n  /**\n   * The day of the week to run this rule at\n   *\n   * @default - Any day of the week\n   */\n  readonly weekDay?: string;\n}\n\nclass LiteralSchedule extends Schedule {\n  constructor(public readonly expressionString: string) {\n    super();\n  }\n\n  public _bind() {}\n}\n\nfunction fallback<T>(x: T | undefined, def: T): T {\n  return x === undefined ? def : x;\n}\n\nfunction formatISO(date?: Date) {\n  if (!date) {\n    return undefined;\n  }\n\n  return (\n    date.getUTCFullYear() +\n    \"-\" +\n    pad(date.getUTCMonth() + 1) +\n    \"-\" +\n    pad(date.getUTCDate()) +\n    \"T\" +\n    pad(date.getUTCHours()) +\n    \":\" +\n    pad(date.getUTCMinutes()) +\n    \":\" +\n    pad(date.getUTCSeconds())\n  );\n\n  function pad(num: number) {\n    if (num < 10) {\n      return \"0\" + num;\n    }\n    return num;\n  }\n}\n\n/**\n * Return the rate if the rate is whole number\n */\nfunction maybeRate(interval: number, singular: string) {\n  if (interval === 0 || !Number.isInteger(interval)) {\n    return undefined;\n  }\n  return makeRate(interval, singular);\n}\n\n/**\n * Return 'rate(${interval} ${singular}(s))` for the interval\n */\nfunction makeRate(interval: number, singular: string) {\n  return interval === 1\n    ? `rate(1 ${singular})`\n    : `rate(${interval} ${singular}s)`;\n}\n"]}