@alicloud/ros-cdk-ecs 1.0.21 → 1.0.23

package/lib/capacityreservation.d.ts

@@ -0,0 +1,69 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosCapacityReservation } from './ecs.generated';
+export { RosCapacityReservation as CapacityReservationProperty };
+/**
+ * Properties for defining a `CapacityReservation`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-capacityreservation
+ */
+export interface CapacityReservationProps {
+    /**
+     * Property instanceAmount: The total number of instances for which to reserve capacity of an instance type.
+     */
+    readonly instanceAmount: number | ros.IResolvable;
+    /**
+     * Property instanceType: The instance type. A capacity reservation can be created to reserve the capacity of only a single instance type. You can call the DescribeInstanceTypes operation to query the instance types provided by ECS.
+     */
+    readonly instanceType: string | ros.IResolvable;
+    /**
+     * Property zoneId: The ID of zone N within the region in which to create the capacity reservation. A capacity reservation can reserve resources within only a single zone.
+     */
+    readonly zoneId: string | ros.IResolvable;
+    /**
+     * Property description: The description of the capacity reservation. The description must be 2 to 256 characters in length and cannot start with http:\/\/ or https:\/\/.
+     * This parameter is empty by default.
+     */
+    readonly description?: string | ros.IResolvable;
+    /**
+     * Property endTime: The time when the capacity reservation expires. Specify the time in the ISO 8601 standard in the yyyy-MM-ddTHH:mm:ssZ format. The time must be in UTC. For more information, see ISO 8601.
+     */
+    readonly endTime?: string | ros.IResolvable;
+    /**
+     * Property endTimeType: The release mode of the capacity reservation. Valid values:
+     * Limited: The capacity reservation is automatically released at the specified time. If you specify this parameter, you must also specify the EndTime parameter.
+     * Unlimited: The capacity reservation must be manually released. You can release it anytime.
+     */
+    readonly endTimeType?: string | ros.IResolvable;
+    /**
+     * Property privatePoolOptions:
+     */
+    readonly privatePoolOptions?: RosCapacityReservation.PrivatePoolOptionsProperty | ros.IResolvable;
+    /**
+     * Property resourceGroupId: The ID of the resource group to which to assign the capacity reservation.
+     */
+    readonly resourceGroupId?: string | ros.IResolvable;
+    /**
+     * Property tags:
+     */
+    readonly tags?: RosCapacityReservation.TagsProperty[];
+}
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::CapacityReservation`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosCapacityReservation`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-capacityreservation
+ */
+export declare class CapacityReservation extends ros.Resource {
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: CapacityReservationProps;
+    protected enableResourcePropertyConstraint: boolean;
+    /**
+     * Attribute PrivatePoolOptionsId: The ID of the capacity reservation.
+     */
+    readonly attrPrivatePoolOptionsId: ros.IResolvable;
+    /**
+     * Param scope - scope in which this resource is defined
+     * Param id    - scoped id of the resource
+     * Param props - resource properties
+     */
+    constructor(scope: ros.Construct, id: string, props: CapacityReservationProps, enableResourcePropertyConstraint?: boolean);
+}

package/lib/capacityreservation.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapacityReservation = exports.CapacityReservationProperty = void 0;
+const ros = require("@alicloud/ros-cdk-core");
+const ecs_generated_1 = require("./ecs.generated");
+Object.defineProperty(exports, "CapacityReservationProperty", { enumerable: true, get: function () { return ecs_generated_1.RosCapacityReservation; } });
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::CapacityReservation`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosCapacityReservation`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-capacityreservation
+ */
+class CapacityReservation extends ros.Resource {
+    /**
+     * Param scope - scope in which this resource is defined
+     * Param id    - scoped id of the resource
+     * Param props - resource properties
+     */
+    constructor(scope, id, props, enableResourcePropertyConstraint = true) {
+        super(scope, id);
+        this.scope = scope;
+        this.id = id;
+        this.props = props;
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
+        const rosCapacityReservation = new ecs_generated_1.RosCapacityReservation(this, id, {
+            instanceAmount: props.instanceAmount,
+            description: props.description,
+            privatePoolOptions: props.privatePoolOptions,
+            zoneId: props.zoneId,
+            resourceGroupId: props.resourceGroupId,
+            endTime: props.endTime,
+            endTimeType: props.endTimeType,
+            instanceType: props.instanceType,
+            tags: props.tags,
+        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
+        this.resource = rosCapacityReservation;
+        this.attrPrivatePoolOptionsId = rosCapacityReservation.attrPrivatePoolOptionsId;
+    }
+}
+exports.CapacityReservation = CapacityReservation;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/command.d.ts

@@ -2,7 +2,8 @@ import * as ros from '@alicloud/ros-cdk-core';
 import { RosCommand } from './ecs.generated';
 export { RosCommand as CommandProperty };
 /**
- * Properties for defining a `ALIYUN::ECS::Command`
+ * Properties for defining a `Command`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-command
  */
 export interface CommandProps {
     /**
@@ -40,20 +41,20 @@ export interface CommandProps {
     readonly workingDir?: string | ros.IResolvable;
 }
 /**
- * A ROS resource type:  `ALIYUN::ECS::Command`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::Command`, which is used to create a Cloud Assistant command.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosCommand`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-command
  */
 export declare class Command extends ros.Resource {
-    /**
-     * A factory method that creates a new instance of this class from an object
-     * containing the properties of this ROS resource, which will be assigned to ROS resource.
-     */
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: CommandProps;
+    protected enableResourcePropertyConstraint: boolean;
     /**
      * Attribute CommandId: The id of command created.
      */
     readonly attrCommandId: ros.IResolvable;
     /**
-     * Create a new `ALIYUN::ECS::Command`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties

package/lib/command.js

@@ -5,18 +5,22 @@ const ros = require("@alicloud/ros-cdk-core");
 const ecs_generated_1 = require("./ecs.generated");
 Object.defineProperty(exports, "CommandProperty", { enumerable: true, get: function () { return ecs_generated_1.RosCommand; } });
 /**
- * A ROS resource type:  `ALIYUN::ECS::Command`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::Command`, which is used to create a Cloud Assistant command.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosCommand`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-command
  */
 class Command extends ros.Resource {
     /**
-     * Create a new `ALIYUN::ECS::Command`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties
      */
     constructor(scope, id, props, enableResourcePropertyConstraint = true) {
         super(scope, id);
+        this.scope = scope;
+        this.id = id;
+        this.props = props;
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
         const rosCommand = new ecs_generated_1.RosCommand(this, id, {
             workingDir: props.workingDir,
             commandContent: props.commandContent,
@@ -32,4 +36,4 @@ class Command extends ros.Resource {
     }
 }
 exports.Command = Command;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/copyimage.d.ts

@@ -2,7 +2,8 @@ import * as ros from '@alicloud/ros-cdk-core';
 import { RosCopyImage } from './ecs.generated';
 export { RosCopyImage as CopyImageProperty };
 /**
- * Properties for defining a `ALIYUN::ECS::CopyImage`
+ * Properties for defining a `CopyImage`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-copyimage
  */
 export interface CopyImageProps {
     /**
@@ -14,7 +15,12 @@ export interface CopyImageProps {
      */
     readonly imageId: string | ros.IResolvable;
     /**
-     * Property destinationDescription: The description of the destination custom image.It cannot begin with http:// or https://.  Default value: null.
+     * Property allowCopyInSameRegion: Whether to allow copying images in the same region.
+     * If set to true, the image will not be copied, the source image id will be returned, and the original image will not be deleted.
+     */
+    readonly allowCopyInSameRegion?: boolean | ros.IResolvable;
+    /**
+     * Property destinationDescription: The description of the destination custom image.It cannot begin with http:\/\/ or https:\/\/.  Default value: null.
      */
     readonly destinationDescription?: string | ros.IResolvable;
     /**
@@ -43,13 +49,15 @@ export interface CopyImageProps {
     readonly tag?: Array<ros.RosTag | ros.IResolvable> | ros.IResolvable;
 }
 /**
- * A ROS resource type:  `ALIYUN::ECS::CopyImage`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::CopyImage`, which is used to copy a custom image from one region to another region.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosCopyImage`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-copyimage
  */
 export declare class CopyImage extends ros.Resource {
-    /**
-     * A factory method that creates a new instance of this class from an object
-     * containing the properties of this ROS resource, which will be assigned to ROS resource.
-     */
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: CopyImageProps;
+    protected enableResourcePropertyConstraint: boolean;
     /**
      * Attribute DestinationRegionId: ID of the region to where the destination custom image belongs.
      */
@@ -63,8 +71,6 @@ export declare class CopyImage extends ros.Resource {
      */
     readonly attrSourceRegionId: ros.IResolvable;
     /**
-     * Create a new `ALIYUN::ECS::CopyImage`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties

package/lib/copyimage.js

@@ -5,22 +5,27 @@ const ros = require("@alicloud/ros-cdk-core");
 const ecs_generated_1 = require("./ecs.generated");
 Object.defineProperty(exports, "CopyImageProperty", { enumerable: true, get: function () { return ecs_generated_1.RosCopyImage; } });
 /**
- * A ROS resource type:  `ALIYUN::ECS::CopyImage`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::CopyImage`, which is used to copy a custom image from one region to another region.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosCopyImage`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-copyimage
  */
 class CopyImage extends ros.Resource {
     /**
-     * Create a new `ALIYUN::ECS::CopyImage`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties
      */
     constructor(scope, id, props, enableResourcePropertyConstraint = true) {
         super(scope, id);
+        this.scope = scope;
+        this.id = id;
+        this.props = props;
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
         const rosCopyImage = new ecs_generated_1.RosCopyImage(this, id, {
             sourceRegionId: props.sourceRegionId,
             kmsKeyId: props.kmsKeyId,
             resourceGroupId: props.resourceGroupId,
+            allowCopyInSameRegion: props.allowCopyInSameRegion,
             destinationRegionId: props.destinationRegionId,
             encrypted: props.encrypted,
             imageId: props.imageId,
@@ -35,4 +40,4 @@ class CopyImage extends ros.Resource {
     }
 }
 exports.CopyImage = CopyImage;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copyimage.js","sourceRoot":"","sources":["copyimage.ts"],"names":[],"mappings":";;;AAAA,8CAA8C;AAC9C,mDAA+C;AAEtB,kGAFhB,4BAAY,OAEqB;AA4D1C;;;;GAIG;AACH,MAAa,SAAU,SAAQ,GAAG,CAAC,QAAQ;IAqBvC;;;;OAIG;IACH,YAAY,KAAoB,EAAE,EAAU,EAAE,KAAqB,EAAE,mCAA2C,IAAI;QAChH,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,gCAAgC,GAAG,gCAAgC,CAAC;QAEzE,MAAM,YAAY,GAAG,IAAI,4BAAY,CAAC,IAAI,EAAE,EAAE,EAAG;YAC7C,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,qBAAqB,EAAE,KAAK,CAAC,qBAAqB;YAClD,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;YAC9C,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,sBAAsB,EAAE,KAAK,CAAC,sBAAsB;YACpD,GAAG,EAAE,KAAK,CAAC,GAAG;YACd,oBAAoB,EAAE,KAAK,CAAC,oBAAoB;SACnD,EAAE,gCAAgC,IAAI,IAAI,CAAC,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpF,IAAI,CAAC,QAAQ,GAAG,YAAY,CAAC;QAC7B,IAAI,CAAC,uBAAuB,GAAG,YAAY,CAAC,uBAAuB,CAAC;QACpE,IAAI,CAAC,WAAW,GAAG,YAAY,CAAC,WAAW,CAAC;QAC5C,IAAI,CAAC,kBAAkB,GAAG,YAAY,CAAC,kBAAkB,CAAC;IAC9D,CAAC;CACJ;AAlDD,8BAkDC","sourcesContent":["import * as ros from '@alicloud/ros-cdk-core';\nimport { RosCopyImage } from './ecs.generated';\n// Generated from the AliCloud ROS Resource Specification\nexport { RosCopyImage as CopyImageProperty };\n\n/**\n * Properties for defining a `CopyImage`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-copyimage\n */\nexport interface CopyImageProps {\n\n    /**\n     * Property destinationRegionId: ID of the region to where the destination custom image belongs.\n     */\n    readonly destinationRegionId: string | ros.IResolvable;\n\n    /**\n     * Property imageId: ID of the source custom image.\n     */\n    readonly imageId: string | ros.IResolvable;\n\n    /**\n     * Property allowCopyInSameRegion: Whether to allow copying images in the same region. \n     * If set to true, the image will not be copied, the source image id will be returned, and the original image will not be deleted.\n     */\n    readonly allowCopyInSameRegion?: boolean | ros.IResolvable;\n\n    /**\n     * Property destinationDescription: The description of the destination custom image.It cannot begin with http:\\/\\/ or https:\\/\\/.  Default value: null.\n     */\n    readonly destinationDescription?: string | ros.IResolvable;\n\n    /**\n     * Property destinationImageName: Name of the destination custom image.The name is a string of 2 to 128 characters. It must begin with an English or a Chinese character. It can contain A-Z, a-z, Chinese characters, numbers, periods (.), colons (:), underscores (_), and hyphens (-).  Default value: null.\n     */\n    readonly destinationImageName?: string | ros.IResolvable;\n\n    /**\n     * Property encrypted: Whether to encrypt the image.\n     */\n    readonly encrypted?: boolean | ros.IResolvable;\n\n    /**\n     * Property kmsKeyId: The ID of the key used to encrypt the image.\n     */\n    readonly kmsKeyId?: string | ros.IResolvable;\n\n    /**\n     * Property resourceGroupId: The ID of the resource group to which the image copy belongs. If not provided, the image copy belongs to the default resource group.\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n\n    /**\n     * Property sourceRegionId: ID of the region to where the source image belongs. Default is current region ID.\n     */\n    readonly sourceRegionId?: string | ros.IResolvable;\n\n    /**\n     * Property tag:\n     */\n    readonly tag?: Array<ros.RosTag | ros.IResolvable> | ros.IResolvable;\n}\n\n/**\n * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::CopyImage`, which is used to copy a custom image from one region to another region.\n * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosCopyImage`for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-copyimage\n */\nexport class CopyImage extends ros.Resource {\n    protected scope: ros.Construct;\n    protected id: string;\n    protected props: CopyImageProps;\n    protected enableResourcePropertyConstraint: boolean;\n\n    /**\n     * Attribute DestinationRegionId: ID of the region to where the destination custom image belongs.\n     */\n    public readonly attrDestinationRegionId: ros.IResolvable;\n\n    /**\n     * Attribute ImageId: ID of the source custom image.\n     */\n    public readonly attrImageId: ros.IResolvable;\n\n    /**\n     * Attribute SourceRegionId: ID of the region to where the source image belongs.\n     */\n    public readonly attrSourceRegionId: ros.IResolvable;\n\n    /**\n     * Param scope - scope in which this resource is defined\n     * Param id    - scoped id of the resource\n     * Param props - resource properties\n     */\n    constructor(scope: ros.Construct, id: string, props: CopyImageProps, enableResourcePropertyConstraint:boolean = true) {\n        super(scope, id);\n        this.scope = scope;\n        this.id = id;\n        this.props = props;\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n\n        const rosCopyImage = new RosCopyImage(this, id,  {\n            sourceRegionId: props.sourceRegionId,\n            kmsKeyId: props.kmsKeyId,\n            resourceGroupId: props.resourceGroupId,\n            allowCopyInSameRegion: props.allowCopyInSameRegion,\n            destinationRegionId: props.destinationRegionId,\n            encrypted: props.encrypted,\n            imageId: props.imageId,\n            destinationDescription: props.destinationDescription,\n            tag: props.tag,\n            destinationImageName: props.destinationImageName,\n        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);\n        this.resource = rosCopyImage;\n        this.attrDestinationRegionId = rosCopyImage.attrDestinationRegionId;\n        this.attrImageId = rosCopyImage.attrImageId;\n        this.attrSourceRegionId = rosCopyImage.attrSourceRegionId;\n    }\n}\n"]}

package/lib/customimage.d.ts

@@ -2,7 +2,8 @@ import * as ros from '@alicloud/ros-cdk-core';
 import { RosCustomImage } from './ecs.generated';
 export { RosCustomImage as CustomImageProperty };
 /**
- * Properties for defining a `ALIYUN::ECS::CustomImage`
+ * Properties for defining a `CustomImage`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-customimage
  */
 export interface CustomImageProps {
     /**
@@ -11,27 +12,43 @@ export interface CustomImageProps {
      * X86_64 (default)
      */
     readonly architecture?: string | ros.IResolvable;
+    /**
+     * Property bootMode: Modify the startup mode of the image. Ranges:
+     * BIOS: BIOS boot mode.
+     * UEFI: UEFI boot mode.
+     * You need to know the startup mode supported by the specified image. After modifying the startup mode through this parameter, it must match the startup mode supported by the image itself so that the instance can start normally.
+     */
+    readonly bootMode?: string | ros.IResolvable;
     /**
      * Property description: The description of the image.
      * It can be [0, 256] letters in length.
-     * It cannot begin with http:// or https://.
+     * It cannot begin with http:\/\/ or https:\/\/.
      * Default value: null.
      */
     readonly description?: string | ros.IResolvable;
+    /**
+     * Property detectionStrategy: Image detection policy. If this parameter is not configured, detection will not be triggered. Only Standard detection mode is supported.Currently, most Linux\/Windows versions are supported.
+     */
+    readonly detectionStrategy?: string | ros.IResolvable;
     /**
      * Property diskDeviceMapping:
      */
     readonly diskDeviceMapping?: Array<RosCustomImage.DiskDeviceMappingProperty | ros.IResolvable> | ros.IResolvable;
     /**
-     * Property imageFamily: The name of the image family of the custom image. The name must be 2 to 128 characters in length and can contain letters, digits, colons (:), underscores (_), and hyphens (-). It cannot contain http:// or https://. It must start with a letter and cannot start with acs: or aliyun.This parameter is empty by default.
+     * Property imageFamily: The name of the image family of the image. The name must be 2 to 128 characters in length and can contain letters, digits, colons (:), underscores (_), and hyphens (-). It cannot contain http:\/\/ or https:\/\/. It must start with a letter and cannot start with acs: or aliyun.This parameter is empty by default.
      */
     readonly imageFamily?: string | ros.IResolvable;
     /**
      * Property imageName: Image name.
      * Can contain [2, 128] characters in length. Must begin with an English letter or Chinese character. Can contain digits, colons (:), underscores (_), or hyphens (-).
-     * Cannot begin with http:// or https://.
+     * Cannot begin with http:\/\/ or https:\/\/.
      */
     readonly imageName?: string | ros.IResolvable;
+    /**
+     * Property imageVersion: Image version.
+     * When you specify an instance ID (InstanceId) and the image of the instance is a cloud market image or a custom image created from a cloud market image. This parameter must be the same as the ImageVersion of the current instance image or set to empty.
+     */
+    readonly imageVersion?: string | ros.IResolvable;
     /**
      * Property instanceId: Instance ID.
      */
@@ -49,7 +66,7 @@ export interface CustomImageProps {
      */
     readonly snapshotId?: string | ros.IResolvable;
     /**
-     * Property sourceRegionId: ID of the region to where the instance/snapshot belongs. Default is current region ID.
+     * Property sourceRegionId: ID of the region to where the instance\/snapshot belongs. Default is current region ID.
      */
     readonly sourceRegionId?: string | ros.IResolvable;
     /**
@@ -58,13 +75,15 @@ export interface CustomImageProps {
     readonly tag?: Array<ros.RosTag | ros.IResolvable> | ros.IResolvable;
 }
 /**
- * A ROS resource type:  `ALIYUN::ECS::CustomImage`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::CustomImage`, which is used to create a custom image.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosCustomImage`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-customimage
  */
 export declare class CustomImage extends ros.Resource {
-    /**
-     * A factory method that creates a new instance of this class from an object
-     * containing the properties of this ROS resource, which will be assigned to ROS resource.
-     */
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: CustomImageProps;
+    protected enableResourcePropertyConstraint: boolean;
     /**
      * Attribute ImageId: Image ID
      */
@@ -74,8 +93,6 @@ export declare class CustomImage extends ros.Resource {
      */
     readonly attrSourceRegionId: ros.IResolvable;
     /**
-     * Create a new `ALIYUN::ECS::CustomImage`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties

package/lib/customimage.js

@@ -5,30 +5,37 @@ const ros = require("@alicloud/ros-cdk-core");
 const ecs_generated_1 = require("./ecs.generated");
 Object.defineProperty(exports, "CustomImageProperty", { enumerable: true, get: function () { return ecs_generated_1.RosCustomImage; } });
 /**
- * A ROS resource type:  `ALIYUN::ECS::CustomImage`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::CustomImage`, which is used to create a custom image.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosCustomImage`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-customimage
  */
 class CustomImage extends ros.Resource {
     /**
-     * Create a new `ALIYUN::ECS::CustomImage`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties
      */
     constructor(scope, id, props = {}, enableResourcePropertyConstraint = true) {
         super(scope, id);
+        this.scope = scope;
+        this.id = id;
+        this.props = props;
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
         const rosCustomImage = new ecs_generated_1.RosCustomImage(this, id, {
-            imageName: props.imageName,
-            sourceRegionId: props.sourceRegionId,
-            snapshotId: props.snapshotId,
+            detectionStrategy: props.detectionStrategy,
             description: props.description,
-            resourceGroupId: props.resourceGroupId,
             platform: props.platform,
             architecture: props.architecture,
+            resourceGroupId: props.resourceGroupId,
             instanceId: props.instanceId,
+            bootMode: props.bootMode,
             imageFamily: props.imageFamily,
-            tag: props.tag,
             diskDeviceMapping: props.diskDeviceMapping,
+            imageName: props.imageName,
+            sourceRegionId: props.sourceRegionId,
+            snapshotId: props.snapshotId,
+            imageVersion: props.imageVersion,
+            tag: props.tag,
         }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
         this.resource = rosCustomImage;
         this.attrImageId = rosCustomImage.attrImageId;
@@ -36,4 +43,4 @@ class CustomImage extends ros.Resource {
     }
 }
 exports.CustomImage = CustomImage;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"customimage.js","sourceRoot":"","sources":["customimage.ts"],"names":[],"mappings":";;;AAAA,8CAA8C;AAC9C,mDAAiD;AAEtB,oGAFlB,8BAAc,OAEuB;AA0F9C;;;;GAIG;AACH,MAAa,WAAY,SAAQ,GAAG,CAAC,QAAQ;IAgBzC;;;;OAIG;IACH,YAAY,KAAoB,EAAE,EAAU,EAAE,QAA0B,EAAE,EAAE,mCAA2C,IAAI;QACvH,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,gCAAgC,GAAG,gCAAgC,CAAC;QAEzE,MAAM,cAAc,GAAG,IAAI,8BAAc,CAAC,IAAI,EAAE,EAAE,EAAG;YACjD,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;YAC1C,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;YAC1C,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,GAAG,EAAE,KAAK,CAAC,GAAG;SACjB,EAAE,gCAAgC,IAAI,IAAI,CAAC,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpF,IAAI,CAAC,QAAQ,GAAG,cAAc,CAAC;QAC/B,IAAI,CAAC,WAAW,GAAG,cAAc,CAAC,WAAW,CAAC;QAC9C,IAAI,CAAC,kBAAkB,GAAG,cAAc,CAAC,kBAAkB,CAAC;IAChE,CAAC;CACJ;AAhDD,kCAgDC","sourcesContent":["import * as ros from '@alicloud/ros-cdk-core';\nimport { RosCustomImage } from './ecs.generated';\n// Generated from the AliCloud ROS Resource Specification\nexport { RosCustomImage as CustomImageProperty };\n\n/**\n * Properties for defining a `CustomImage`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-customimage\n */\nexport interface CustomImageProps {\n\n    /**\n     * Property architecture: After specifying the data disk snapshot as the mirrored system disk, you need to determine the system architecture of the system disk through Architecture. Ranges:\n     * I386\n     * X86_64 (default)\n     */\n    readonly architecture?: string | ros.IResolvable;\n\n    /**\n     * Property bootMode: Modify the startup mode of the image. Ranges:\n     * BIOS: BIOS boot mode.\n     * UEFI: UEFI boot mode.\n     * You need to know the startup mode supported by the specified image. After modifying the startup mode through this parameter, it must match the startup mode supported by the image itself so that the instance can start normally.\n     */\n    readonly bootMode?: string | ros.IResolvable;\n\n    /**\n     * Property description: The description of the image.\n     * It can be [0, 256] letters in length.\n     * It cannot begin with http:\\/\\/ or https:\\/\\/.\n     * Default value: null.\n     */\n    readonly description?: string | ros.IResolvable;\n\n    /**\n     * Property detectionStrategy: Image detection policy. If this parameter is not configured, detection will not be triggered. Only Standard detection mode is supported.Currently, most Linux\\/Windows versions are supported.\n     */\n    readonly detectionStrategy?: string | ros.IResolvable;\n\n    /**\n     * Property diskDeviceMapping:\n     */\n    readonly diskDeviceMapping?: Array<RosCustomImage.DiskDeviceMappingProperty | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * Property imageFamily: The name of the image family of the image. The name must be 2 to 128 characters in length and can contain letters, digits, colons (:), underscores (_), and hyphens (-). It cannot contain http:\\/\\/ or https:\\/\\/. It must start with a letter and cannot start with acs: or aliyun.This parameter is empty by default.\n     */\n    readonly imageFamily?: string | ros.IResolvable;\n\n    /**\n     * Property imageName: Image name.\n     * Can contain [2, 128] characters in length. Must begin with an English letter or Chinese character. Can contain digits, colons (:), underscores (_), or hyphens (-).\n     * Cannot begin with http:\\/\\/ or https:\\/\\/.\n     */\n    readonly imageName?: string | ros.IResolvable;\n\n    /**\n     * Property imageVersion: Image version.\n     * When you specify an instance ID (InstanceId) and the image of the instance is a cloud market image or a custom image created from a cloud market image. This parameter must be the same as the ImageVersion of the current instance image or set to empty.\n     */\n    readonly imageVersion?: string | ros.IResolvable;\n\n    /**\n     * Property instanceId: Instance ID.\n     */\n    readonly instanceId?: string | ros.IResolvable;\n\n    /**\n     * Property platform: After specifying the data disk snapshot as the mirrored system disk, you need to determine the operating system release of the system disk through Platform.\n     */\n    readonly platform?: string | ros.IResolvable;\n\n    /**\n     * Property resourceGroupId: The ID of the resource group to which to assign the custom image.\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n\n    /**\n     * Property snapshotId: The snapshot ID. A custom image is created from the specified snapshot.\n     */\n    readonly snapshotId?: string | ros.IResolvable;\n\n    /**\n     * Property sourceRegionId: ID of the region to where the instance\\/snapshot belongs. Default is current region ID.\n     */\n    readonly sourceRegionId?: string | ros.IResolvable;\n\n    /**\n     * Property tag:\n     */\n    readonly tag?: Array<ros.RosTag | ros.IResolvable> | ros.IResolvable;\n}\n\n/**\n * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::CustomImage`, which is used to create a custom image.\n * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosCustomImage`for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-customimage\n */\nexport class CustomImage extends ros.Resource {\n    protected scope: ros.Construct;\n    protected id: string;\n    protected props: CustomImageProps;\n    protected enableResourcePropertyConstraint: boolean;\n\n    /**\n     * Attribute ImageId: Image ID\n     */\n    public readonly attrImageId: ros.IResolvable;\n\n    /**\n     * Attribute SourceRegionId: ID of the region to where the instance/snapshot belongs.\n     */\n    public readonly attrSourceRegionId: ros.IResolvable;\n\n    /**\n     * Param scope - scope in which this resource is defined\n     * Param id    - scoped id of the resource\n     * Param props - resource properties\n     */\n    constructor(scope: ros.Construct, id: string, props: CustomImageProps = {}, enableResourcePropertyConstraint:boolean = true) {\n        super(scope, id);\n        this.scope = scope;\n        this.id = id;\n        this.props = props;\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n\n        const rosCustomImage = new RosCustomImage(this, id,  {\n            detectionStrategy: props.detectionStrategy,\n            description: props.description,\n            platform: props.platform,\n            architecture: props.architecture,\n            resourceGroupId: props.resourceGroupId,\n            instanceId: props.instanceId,\n            bootMode: props.bootMode,\n            imageFamily: props.imageFamily,\n            diskDeviceMapping: props.diskDeviceMapping,\n            imageName: props.imageName,\n            sourceRegionId: props.sourceRegionId,\n            snapshotId: props.snapshotId,\n            imageVersion: props.imageVersion,\n            tag: props.tag,\n        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);\n        this.resource = rosCustomImage;\n        this.attrImageId = rosCustomImage.attrImageId;\n        this.attrSourceRegionId = rosCustomImage.attrSourceRegionId;\n    }\n}\n"]}

package/lib/datasource/activations.d.ts

@@ -2,7 +2,8 @@ import * as ros from '@alicloud/ros-cdk-core';
 import { RosActivations } from './ecs.generated';
 export { RosActivations as ActivationsProperty };
 /**
- * Properties for defining a `DATASOURCE::ECS::Activations`
+ * Properties for defining a `Activations`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ecs-activations
  */
 export interface ActivationsProps {
     /**
@@ -15,13 +16,15 @@ export interface ActivationsProps {
     readonly instanceName?: string | ros.IResolvable;
 }
 /**
- * A ROS resource type:  `DATASOURCE::ECS::Activations`
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::ECS::Activations`, which is used to query activation codes.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosActivations`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ecs-activations
  */
 export declare class Activations extends ros.Resource {
-    /**
-     * A factory method that creates a new instance of this class from an object
-     * containing the properties of this ROS resource, which will be assigned to ROS resource.
-     */
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: ActivationsProps;
+    protected enableResourcePropertyConstraint: boolean;
     /**
      * Attribute ActivationIds: The list of activation IDs.
      */
@@ -31,8 +34,6 @@ export declare class Activations extends ros.Resource {
      */
     readonly attrActivations: ros.IResolvable;
     /**
-     * Create a new `DATASOURCE::ECS::Activations`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties

package/lib/datasource/activations.js

@@ -5,18 +5,22 @@ const ros = require("@alicloud/ros-cdk-core");
 const ecs_generated_1 = require("./ecs.generated");
 Object.defineProperty(exports, "ActivationsProperty", { enumerable: true, get: function () { return ecs_generated_1.RosActivations; } });
 /**
- * A ROS resource type:  `DATASOURCE::ECS::Activations`
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::ECS::Activations`, which is used to query activation codes.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosActivations`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ecs-activations
  */
 class Activations extends ros.Resource {
     /**
-     * Create a new `DATASOURCE::ECS::Activations`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties
      */
     constructor(scope, id, props = {}, enableResourcePropertyConstraint = true) {
         super(scope, id);
+        this.scope = scope;
+        this.id = id;
+        this.props = props;
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
         const rosActivations = new ecs_generated_1.RosActivations(this, id, {
             instanceName: props.instanceName,
             activationId: props.activationId,
@@ -27,4 +31,4 @@ class Activations extends ros.Resource {
     }
 }
 exports.Activations = Activations;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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