@alicloud/ros-cdk-ecs 1.0.21 → 1.0.23

package/lib/elasticityassurance.d.ts

@@ -0,0 +1,78 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosElasticityAssurance } from './ecs.generated';
+export { RosElasticityAssurance as ElasticityAssuranceProperty };
+/**
+ * Properties for defining a `ElasticityAssurance`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-elasticityassurance
+ */
+export interface ElasticityAssuranceProps {
+    /**
+     * Property instanceAmount: The total number of instances for which to reserve capacity of an instance type.
+     * Valid values: 1 to 1000.
+     */
+    readonly instanceAmount: number | ros.IResolvable;
+    /**
+     * Property instanceTypes: Instance type. Currently, an elasticity assurance can be created to reserve the capacity of a single instance type.
+     */
+    readonly instanceTypes: Array<string | ros.IResolvable> | ros.IResolvable;
+    /**
+     * Property zoneId: The zone ID of the elasticity assurance. Currently, an elasticity assurance can be used to reserve resources within a single zone.
+     */
+    readonly zoneId: string | ros.IResolvable;
+    /**
+     * Property description: The description of the elasticity assurance. 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 period: The effective duration of the elasticity assurance. The unit of the effective duration is determined by the PeriodUnit value. Valid values:
+     * When the PeriodUnit parameter is set to Month, the valid values are 1, 2, 3, 4, 5, 6, 7, 8, and 9.
+     * When the PeriodUnit parameter is set to Year, the valid values are 1, 2, 3, 4, and 5.
+     * Default value: 1.
+     */
+    readonly period?: number | ros.IResolvable;
+    /**
+     * Property periodUnit: The unit of the effective duration of the elasticity assurance. Valid values:
+     * Month
+     * Year
+     * Default value: Year.
+     */
+    readonly periodUnit?: string | ros.IResolvable;
+    /**
+     * Property privatePoolOptions:
+     */
+    readonly privatePoolOptions?: RosElasticityAssurance.PrivatePoolOptionsProperty | ros.IResolvable;
+    /**
+     * Property resourceGroupId: The ID of the resource group to which to assign the elasticity assurance.
+     */
+    readonly resourceGroupId?: string | ros.IResolvable;
+    /**
+     * Property startTime: The time when the elasticity assurance takes effect. The default value is the time when the CreateElasticityAssurance operation is called to create the elasticity assurance. 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 startTime?: string | ros.IResolvable;
+    /**
+     * Property tags:
+     */
+    readonly tags?: RosElasticityAssurance.TagsProperty[];
+}
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::ElasticityAssurance`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosElasticityAssurance`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-elasticityassurance
+ */
+export declare class ElasticityAssurance extends ros.Resource {
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: ElasticityAssuranceProps;
+    protected enableResourcePropertyConstraint: boolean;
+    /**
+     * Attribute PrivatePoolOptionsId: The ID of the elasticity assurance.
+     */
+    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: ElasticityAssuranceProps, enableResourcePropertyConstraint?: boolean);
+}

package/lib/elasticityassurance.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElasticityAssurance = exports.ElasticityAssuranceProperty = void 0;
+const ros = require("@alicloud/ros-cdk-core");
+const ecs_generated_1 = require("./ecs.generated");
+Object.defineProperty(exports, "ElasticityAssuranceProperty", { enumerable: true, get: function () { return ecs_generated_1.RosElasticityAssurance; } });
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::ElasticityAssurance`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosElasticityAssurance`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-elasticityassurance
+ */
+class ElasticityAssurance 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 rosElasticityAssurance = new ecs_generated_1.RosElasticityAssurance(this, id, {
+            description: props.description,
+            instanceAmount: props.instanceAmount,
+            privatePoolOptions: props.privatePoolOptions,
+            zoneId: props.zoneId,
+            resourceGroupId: props.resourceGroupId,
+            startTime: props.startTime,
+            period: props.period,
+            instanceTypes: props.instanceTypes,
+            tags: props.tags,
+            periodUnit: props.periodUnit,
+        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
+        this.resource = rosElasticityAssurance;
+        this.attrPrivatePoolOptionsId = rosElasticityAssurance.attrPrivatePoolOptionsId;
+    }
+}
+exports.ElasticityAssurance = ElasticityAssurance;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"elasticityassurance.js","sourceRoot":"","sources":["elasticityassurance.ts"],"names":[],"mappings":";;;AAAA,8CAA8C;AAC9C,mDAAyD;AAEtB,4GAF1B,sCAAsB,OAE+B;AAmE9D;;;;GAIG;AACH,MAAa,mBAAoB,SAAQ,GAAG,CAAC,QAAQ;IAWjD;;;;OAIG;IACH,YAAY,KAAoB,EAAE,EAAU,EAAE,KAA+B,EAAE,mCAA2C,IAAI;QAC1H,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,sBAAsB,GAAG,IAAI,sCAAsB,CAAC,IAAI,EAAE,EAAE,EAAG;YACjE,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;YAC5C,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,UAAU,EAAE,KAAK,CAAC,UAAU;SAC/B,EAAE,gCAAgC,IAAI,IAAI,CAAC,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpF,IAAI,CAAC,QAAQ,GAAG,sBAAsB,CAAC;QACvC,IAAI,CAAC,wBAAwB,GAAG,sBAAsB,CAAC,wBAAwB,CAAC;IACpF,CAAC;CACJ;AAtCD,kDAsCC","sourcesContent":["import * as ros from '@alicloud/ros-cdk-core';\nimport { RosElasticityAssurance } from './ecs.generated';\n// Generated from the AliCloud ROS Resource Specification\nexport { RosElasticityAssurance as ElasticityAssuranceProperty };\n\n/**\n * Properties for defining a `ElasticityAssurance`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-elasticityassurance\n */\nexport interface ElasticityAssuranceProps {\n\n    /**\n     * Property instanceAmount: The total number of instances for which to reserve capacity of an instance type.\n     * Valid values: 1 to 1000.\n     */\n    readonly instanceAmount: number | ros.IResolvable;\n\n    /**\n     * Property instanceTypes: Instance type. Currently, an elasticity assurance can be created to reserve the capacity of a single instance type.\n     */\n    readonly instanceTypes: Array<string | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * Property zoneId: The zone ID of the elasticity assurance. Currently, an elasticity assurance can be used to reserve resources within a single zone.\n     */\n    readonly zoneId: string | ros.IResolvable;\n\n    /**\n     * Property description: The description of the elasticity assurance. The description must be 2 to 256 characters in length and cannot start with http:\\/\\/ or https:\\/\\/.\n     * This parameter is empty by default.\n     */\n    readonly description?: string | ros.IResolvable;\n\n    /**\n     * Property period: The effective duration of the elasticity assurance. The unit of the effective duration is determined by the PeriodUnit value. Valid values:\n     * When the PeriodUnit parameter is set to Month, the valid values are 1, 2, 3, 4, 5, 6, 7, 8, and 9.\n     * When the PeriodUnit parameter is set to Year, the valid values are 1, 2, 3, 4, and 5.\n     * Default value: 1.\n     */\n    readonly period?: number | ros.IResolvable;\n\n    /**\n     * Property periodUnit: The unit of the effective duration of the elasticity assurance. Valid values:\n     * Month\n     * Year\n     * Default value: Year.\n     */\n    readonly periodUnit?: string | ros.IResolvable;\n\n    /**\n     * Property privatePoolOptions:\n     */\n    readonly privatePoolOptions?: RosElasticityAssurance.PrivatePoolOptionsProperty | ros.IResolvable;\n\n    /**\n     * Property resourceGroupId: The ID of the resource group to which to assign the elasticity assurance.\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n\n    /**\n     * Property startTime: The time when the elasticity assurance takes effect. The default value is the time when the CreateElasticityAssurance operation is called to create the elasticity assurance. 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.\n     */\n    readonly startTime?: string | ros.IResolvable;\n\n    /**\n     * Property tags:\n     */\n    readonly tags?: RosElasticityAssurance.TagsProperty[];\n}\n\n/**\n * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::ElasticityAssurance`.\n * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosElasticityAssurance`for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-elasticityassurance\n */\nexport class ElasticityAssurance extends ros.Resource {\n    protected scope: ros.Construct;\n    protected id: string;\n    protected props: ElasticityAssuranceProps;\n    protected enableResourcePropertyConstraint: boolean;\n\n    /**\n     * Attribute PrivatePoolOptionsId: The ID of the elasticity assurance.\n     */\n    public readonly attrPrivatePoolOptionsId: 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: ElasticityAssuranceProps, 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 rosElasticityAssurance = new RosElasticityAssurance(this, id,  {\n            description: props.description,\n            instanceAmount: props.instanceAmount,\n            privatePoolOptions: props.privatePoolOptions,\n            zoneId: props.zoneId,\n            resourceGroupId: props.resourceGroupId,\n            startTime: props.startTime,\n            period: props.period,\n            instanceTypes: props.instanceTypes,\n            tags: props.tags,\n            periodUnit: props.periodUnit,\n        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);\n        this.resource = rosElasticityAssurance;\n        this.attrPrivatePoolOptionsId = rosElasticityAssurance.attrPrivatePoolOptionsId;\n    }\n}\n"]}

package/lib/forwardentry.d.ts

@@ -2,7 +2,8 @@ import * as ros from '@alicloud/ros-cdk-core';
 import { RosForwardEntry } from './ecs.generated';
 export { RosForwardEntry as ForwardEntryProperty };
 /**
- * Properties for defining a `ALIYUN::ECS::ForwardEntry`
+ * Properties for defining a `ForwardEntry`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-forwardentry
  */
 export interface ForwardEntryProps {
     /**
@@ -10,7 +11,7 @@ export interface ForwardEntryProps {
      */
     readonly externalIp: string | ros.IResolvable;
     /**
-     * Property externalPort: Source port, now support [1-65535]|Any|x/y
+     * Property externalPort: Source port, now support [1-65535]|Any|x\/y
      */
     readonly externalPort: string | ros.IResolvable;
     /**
@@ -22,7 +23,7 @@ export interface ForwardEntryProps {
      */
     readonly internalIp: string | ros.IResolvable;
     /**
-     * Property internalPort: Destination port, now support [1-65535]|Any|x/y
+     * Property internalPort: Destination port, now support [1-65535]|Any|x\/y
      */
     readonly internalPort: string | ros.IResolvable;
     /**
@@ -30,7 +31,7 @@ export interface ForwardEntryProps {
      */
     readonly ipProtocol: string | ros.IResolvable;
     /**
-     * Property forwardEntryName: the name of the DNAT rule is 2-128 characters long and must start with a letter or Chinese, but cannot begin with HTTP:// or https://.
+     * Property forwardEntryName: the name of the DNAT rule is 2-128 characters long and must start with a letter or Chinese, but cannot begin with HTTP:\/\/ or https:\/\/.
      */
     readonly forwardEntryName?: string | ros.IResolvable;
     /**
@@ -39,20 +40,20 @@ export interface ForwardEntryProps {
     readonly portBreak?: boolean | ros.IResolvable;
 }
 /**
- * A ROS resource type:  `ALIYUN::ECS::ForwardEntry`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::ForwardEntry`, which is used to configure the Destination Network Address Translation (DNAT) table of a Network Address Translation (NAT) gateway.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosForwardEntry`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-forwardentry
  */
 export declare class ForwardEntry 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: ForwardEntryProps;
+    protected enableResourcePropertyConstraint: boolean;
     /**
      * Attribute ForwardEntryId: The id of created forward entry.
      */
     readonly attrForwardEntryId: ros.IResolvable;
     /**
-     * Create a new `ALIYUN::ECS::ForwardEntry`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties

package/lib/forwardentry.js

@@ -5,18 +5,22 @@ const ros = require("@alicloud/ros-cdk-core");
 const ecs_generated_1 = require("./ecs.generated");
 Object.defineProperty(exports, "ForwardEntryProperty", { enumerable: true, get: function () { return ecs_generated_1.RosForwardEntry; } });
 /**
- * A ROS resource type:  `ALIYUN::ECS::ForwardEntry`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::ForwardEntry`, which is used to configure the Destination Network Address Translation (DNAT) table of a Network Address Translation (NAT) gateway.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosForwardEntry`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-forwardentry
  */
 class ForwardEntry extends ros.Resource {
     /**
-     * Create a new `ALIYUN::ECS::ForwardEntry`.
-     *
      * 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 rosForwardEntry = new ecs_generated_1.RosForwardEntry(this, id, {
             externalPort: props.externalPort,
             externalIp: props.externalIp,
@@ -32,4 +36,4 @@ class ForwardEntry extends ros.Resource {
     }
 }
 exports.ForwardEntry = ForwardEntry;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/hpccluster.d.ts

@@ -2,29 +2,32 @@ import * as ros from '@alicloud/ros-cdk-core';
 import { RosHpcCluster } from './ecs.generated';
 export { RosHpcCluster as HpcClusterProperty };
 /**
- * Properties for defining a `ALIYUN::ECS::HpcCluster`
+ * Properties for defining a `HpcCluster`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-hpccluster
  */
 export interface HpcClusterProps {
     /**
      * Property name: The name of the HPC cluster. The name must be 2 to 128 characters in length. It must
-     * start with a letter but cannot start with http:// or https://. It can contain letters,
+     * start with a letter but cannot start with http:\/\/ or https:\/\/. It can contain letters,
      * digits, colons (:), underscores (_), and hyphens (-).
      */
     readonly name: string | ros.IResolvable;
     /**
      * Property description: The description of the HPC cluster. The description must be 2 to 256 characters in
-     * length. It cannot start with http:// or https://. Default value: empty string.
+     * length. It cannot start with http:\/\/ or https:\/\/. Default value: empty string.
      */
     readonly description?: string | ros.IResolvable;
 }
 /**
- * A ROS resource type:  `ALIYUN::ECS::HpcCluster`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::HpcCluster`, which is used to create a High Performance Computing (HPC) cluster.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosHpcCluster`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-hpccluster
  */
 export declare class HpcCluster 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: HpcClusterProps;
+    protected enableResourcePropertyConstraint: boolean;
     /**
      * Attribute HpcClusterId: The ID of the HPC cluster.
      */
@@ -34,8 +37,6 @@ export declare class HpcCluster extends ros.Resource {
      */
     readonly attrName: ros.IResolvable;
     /**
-     * Create a new `ALIYUN::ECS::HpcCluster`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties

package/lib/hpccluster.js

@@ -5,18 +5,22 @@ const ros = require("@alicloud/ros-cdk-core");
 const ecs_generated_1 = require("./ecs.generated");
 Object.defineProperty(exports, "HpcClusterProperty", { enumerable: true, get: function () { return ecs_generated_1.RosHpcCluster; } });
 /**
- * A ROS resource type:  `ALIYUN::ECS::HpcCluster`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::HpcCluster`, which is used to create a High Performance Computing (HPC) cluster.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosHpcCluster`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-hpccluster
  */
 class HpcCluster extends ros.Resource {
     /**
-     * Create a new `ALIYUN::ECS::HpcCluster`.
-     *
      * 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 rosHpcCluster = new ecs_generated_1.RosHpcCluster(this, id, {
             description: props.description,
             name: props.name,
@@ -27,4 +31,4 @@ class HpcCluster extends ros.Resource {
     }
 }
 exports.HpcCluster = HpcCluster;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/imagecomponent.d.ts

@@ -0,0 +1,59 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosImageComponent } from './ecs.generated';
+export { RosImageComponent as ImageComponentProperty };
+/**
+ * Properties for defining a `ImageComponent`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-imagecomponent
+ */
+export interface ImageComponentProps {
+    /**
+     * Property content: The content of the image component. The content consists of up to 127 commands.
+     */
+    readonly content: string | ros.IResolvable;
+    /**
+     * Property componentType: The type of the image component. Only image build components are supported. Set the value to Build.Default value: Build.
+     */
+    readonly componentType?: string | ros.IResolvable;
+    /**
+     * Property description: The description. The description must be 2 to 256 characters in length and cannot start with http:\/\/ or https:\/\/.
+     */
+    readonly description?: string | ros.IResolvable;
+    /**
+     * Property name: The component name. The name must be 2 to 128 characters in length. The name must start with a letter but cannot start with http:\/\/ or https:\/\/.The name can contain letters, digits, colons (:), underscores (_), periods (.), and hyphens (-).
+     * Note If you do not configure Name, the return value of ImageComponentId is used.
+     */
+    readonly name?: string | ros.IResolvable;
+    /**
+     * Property resourceGroupId: The ID of the resource group.
+     */
+    readonly resourceGroupId?: string | ros.IResolvable;
+    /**
+     * Property systemType: The operating system type supported by the image component. Only Linux is supported. Set the value to Linux.Default value: Linux.
+     */
+    readonly systemType?: string | ros.IResolvable;
+    /**
+     * Property tags:
+     */
+    readonly tags?: RosImageComponent.TagsProperty[];
+}
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::ImageComponent`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosImageComponent`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-imagecomponent
+ */
+export declare class ImageComponent extends ros.Resource {
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: ImageComponentProps;
+    protected enableResourcePropertyConstraint: boolean;
+    /**
+     * Attribute ImageComponentId: The ID of the image component.
+     */
+    readonly attrImageComponentId: 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: ImageComponentProps, enableResourcePropertyConstraint?: boolean);
+}

package/lib/imagecomponent.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageComponent = exports.ImageComponentProperty = void 0;
+const ros = require("@alicloud/ros-cdk-core");
+const ecs_generated_1 = require("./ecs.generated");
+Object.defineProperty(exports, "ImageComponentProperty", { enumerable: true, get: function () { return ecs_generated_1.RosImageComponent; } });
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::ImageComponent`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosImageComponent`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-imagecomponent
+ */
+class ImageComponent 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 rosImageComponent = new ecs_generated_1.RosImageComponent(this, id, {
+            componentType: props.componentType === undefined || props.componentType === null ? 'Build' : props.componentType,
+            description: props.description,
+            resourceGroupId: props.resourceGroupId,
+            content: props.content,
+            systemType: props.systemType === undefined || props.systemType === null ? 'Linux' : props.systemType,
+            tags: props.tags,
+            name: props.name,
+        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
+        this.resource = rosImageComponent;
+        this.attrImageComponentId = rosImageComponent.attrImageComponentId;
+    }
+}
+exports.ImageComponent = ImageComponent;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2Vjb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbWFnZWNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSw4Q0FBOEM7QUFDOUMsbURBQW9EO0FBRXRCLHVHQUZyQixpQ0FBaUIsT0FFMEI7QUE2Q3BEOzs7O0dBSUc7QUFDSCxNQUFhLGNBQWUsU0FBUSxHQUFHLENBQUMsUUFBUTtJQVc1Qzs7OztPQUlHO0lBQ0gsWUFBWSxLQUFvQixFQUFFLEVBQVUsRUFBRSxLQUEwQixFQUFFLG1DQUEyQyxJQUFJO1FBQ3JILEtBQUssQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDakIsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDbkIsSUFBSSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUM7UUFDYixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNuQixJQUFJLENBQUMsZ0NBQWdDLEdBQUcsZ0NBQWdDLENBQUM7UUFFekUsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLGlDQUFpQixDQUFDLElBQUksRUFBRSxFQUFFLEVBQUc7WUFDdkQsYUFBYSxFQUFFLEtBQUssQ0FBQyxhQUFhLEtBQUssU0FBUyxJQUFJLEtBQUssQ0FBQyxhQUFhLEtBQUssSUFBSSxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxhQUFhO1lBQ2hILFdBQVcsRUFBRSxLQUFLLENBQUMsV0FBVztZQUM5QixlQUFlLEVBQUUsS0FBSyxDQUFDLGVBQWU7WUFDdEMsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPO1lBQ3RCLFVBQVUsRUFBRSxLQUFLLENBQUMsVUFBVSxLQUFLLFNBQVMsSUFBSSxLQUFLLENBQUMsVUFBVSxLQUFLLElBQUksQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsVUFBVTtZQUNwRyxJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUk7WUFDaEIsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJO1NBQ25CLEVBQUUsZ0NBQWdDLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQyxnQ0FBZ0MsQ0FBQyxDQUFDO1FBQ3BGLElBQUksQ0FBQyxRQUFRLEdBQUcsaUJBQWlCLENBQUM7UUFDbEMsSUFBSSxDQUFDLG9CQUFvQixHQUFHLGlCQUFpQixDQUFDLG9CQUFvQixDQUFDO0lBQ3ZFLENBQUM7Q0FDSjtBQW5DRCx3Q0FtQ0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyByb3MgZnJvbSAnQGFsaWNsb3VkL3Jvcy1jZGstY29yZSc7XG5pbXBvcnQgeyBSb3NJbWFnZUNvbXBvbmVudCB9IGZyb20gJy4vZWNzLmdlbmVyYXRlZCc7XG4vLyBHZW5lcmF0ZWQgZnJvbSB0aGUgQWxpQ2xvdWQgUk9TIFJlc291cmNlIFNwZWNpZmljYXRpb25cbmV4cG9ydCB7IFJvc0ltYWdlQ29tcG9uZW50IGFzIEltYWdlQ29tcG9uZW50UHJvcGVydHkgfTtcblxuLyoqXG4gKiBQcm9wZXJ0aWVzIGZvciBkZWZpbmluZyBhIGBJbWFnZUNvbXBvbmVudGAuXG4gKiBTZWUgaHR0cHM6Ly93d3cuYWxpYmFiYWNsb3VkLmNvbS9oZWxwL3Jvcy9kZXZlbG9wZXItcmVmZXJlbmNlL2FsaXl1bi1lY3MtaW1hZ2Vjb21wb25lbnRcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBJbWFnZUNvbXBvbmVudFByb3BzIHtcblxuICAgIC8qKlxuICAgICAqIFByb3BlcnR5IGNvbnRlbnQ6IFRoZSBjb250ZW50IG9mIHRoZSBpbWFnZSBjb21wb25lbnQuIFRoZSBjb250ZW50IGNvbnNpc3RzIG9mIHVwIHRvIDEyNyBjb21tYW5kcy5cbiAgICAgKi9cbiAgICByZWFkb25seSBjb250ZW50OiBzdHJpbmcgfCByb3MuSVJlc29sdmFibGU7XG5cbiAgICAvKipcbiAgICAgKiBQcm9wZXJ0eSBjb21wb25lbnRUeXBlOiBUaGUgdHlwZSBvZiB0aGUgaW1hZ2UgY29tcG9uZW50LiBPbmx5IGltYWdlIGJ1aWxkIGNvbXBvbmVudHMgYXJlIHN1cHBvcnRlZC4gU2V0IHRoZSB2YWx1ZSB0byBCdWlsZC5EZWZhdWx0IHZhbHVlOiBCdWlsZC5cbiAgICAgKi9cbiAgICByZWFkb25seSBjb21wb25lbnRUeXBlPzogc3RyaW5nIHwgcm9zLklSZXNvbHZhYmxlO1xuXG4gICAgLyoqXG4gICAgICogUHJvcGVydHkgZGVzY3JpcHRpb246IFRoZSBkZXNjcmlwdGlvbi4gVGhlIGRlc2NyaXB0aW9uIG11c3QgYmUgMiB0byAyNTYgY2hhcmFjdGVycyBpbiBsZW5ndGggYW5kIGNhbm5vdCBzdGFydCB3aXRoIGh0dHA6XFwvXFwvIG9yIGh0dHBzOlxcL1xcLy5cbiAgICAgKi9cbiAgICByZWFkb25seSBkZXNjcmlwdGlvbj86IHN0cmluZyB8IHJvcy5JUmVzb2x2YWJsZTtcblxuICAgIC8qKlxuICAgICAqIFByb3BlcnR5IG5hbWU6IFRoZSBjb21wb25lbnQgbmFtZS4gVGhlIG5hbWUgbXVzdCBiZSAyIHRvIDEyOCBjaGFyYWN0ZXJzIGluIGxlbmd0aC4gVGhlIG5hbWUgbXVzdCBzdGFydCB3aXRoIGEgbGV0dGVyIGJ1dCBjYW5ub3Qgc3RhcnQgd2l0aCBodHRwOlxcL1xcLyBvciBodHRwczpcXC9cXC8uVGhlIG5hbWUgY2FuIGNvbnRhaW4gbGV0dGVycywgZGlnaXRzLCBjb2xvbnMgKDopLCB1bmRlcnNjb3JlcyAoXyksIHBlcmlvZHMgKC4pLCBhbmQgaHlwaGVucyAoLSkuXG4gICAgICogTm90ZSBJZiB5b3UgZG8gbm90IGNvbmZpZ3VyZSBOYW1lLCB0aGUgcmV0dXJuIHZhbHVlIG9mIEltYWdlQ29tcG9uZW50SWQgaXMgdXNlZC5cbiAgICAgKi9cbiAgICByZWFkb25seSBuYW1lPzogc3RyaW5nIHwgcm9zLklSZXNvbHZhYmxlO1xuXG4gICAgLyoqXG4gICAgICogUHJvcGVydHkgcmVzb3VyY2VHcm91cElkOiBUaGUgSUQgb2YgdGhlIHJlc291cmNlIGdyb3VwLlxuICAgICAqL1xuICAgIHJlYWRvbmx5IHJlc291cmNlR3JvdXBJZD86IHN0cmluZyB8IHJvcy5JUmVzb2x2YWJsZTtcblxuICAgIC8qKlxuICAgICAqIFByb3BlcnR5IHN5c3RlbVR5cGU6IFRoZSBvcGVyYXRpbmcgc3lzdGVtIHR5cGUgc3VwcG9ydGVkIGJ5IHRoZSBpbWFnZSBjb21wb25lbnQuIE9ubHkgTGludXggaXMgc3VwcG9ydGVkLiBTZXQgdGhlIHZhbHVlIHRvIExpbnV4LkRlZmF1bHQgdmFsdWU6IExpbnV4LlxuICAgICAqL1xuICAgIHJlYWRvbmx5IHN5c3RlbVR5cGU/OiBzdHJpbmcgfCByb3MuSVJlc29sdmFibGU7XG5cbiAgICAvKipcbiAgICAgKiBQcm9wZXJ0eSB0YWdzOlxuICAgICAqL1xuICAgIHJlYWRvbmx5IHRhZ3M/OiBSb3NJbWFnZUNvbXBvbmVudC5UYWdzUHJvcGVydHlbXTtcbn1cblxuLyoqXG4gKiBUaGlzIGNsYXNzIGVuY2Fwc3VsYXRlcyBhbmQgZXh0ZW5kcyB0aGUgUk9TIHJlc291cmNlIHR5cGUgYEFMSVlVTjo6RUNTOjpJbWFnZUNvbXBvbmVudGAuXG4gKiBATm90ZSBUaGlzIGNsYXNzIG1heSBoYXZlIHNvbWUgbmV3IGZ1bmN0aW9ucyB0byBmYWNpbGl0YXRlIGRldmVsb3BtZW50LCBzbyBpdCBpcyByZWNvbW1lbmRlZCB0byB1c2UgdGhpcyBjbGFzcyBpbnN0ZWFkIG9mIGBSb3NJbWFnZUNvbXBvbmVudGBmb3IgYSBtb3JlIGNvbnZlbmllbnQgZGV2ZWxvcG1lbnQgZXhwZXJpZW5jZS5cbiAqIFNlZSBodHRwczovL3d3dy5hbGliYWJhY2xvdWQuY29tL2hlbHAvcm9zL2RldmVsb3Blci1yZWZlcmVuY2UvYWxpeXVuLWVjcy1pbWFnZWNvbXBvbmVudFxuICovXG5leHBvcnQgY2xhc3MgSW1hZ2VDb21wb25lbnQgZXh0ZW5kcyByb3MuUmVzb3VyY2Uge1xuICAgIHByb3RlY3RlZCBzY29wZTogcm9zLkNvbnN0cnVjdDtcbiAgICBwcm90ZWN0ZWQgaWQ6IHN0cmluZztcbiAgICBwcm90ZWN0ZWQgcHJvcHM6IEltYWdlQ29tcG9uZW50UHJvcHM7XG4gICAgcHJvdGVjdGVkIGVuYWJsZVJlc291cmNlUHJvcGVydHlDb25zdHJhaW50OiBib29sZWFuO1xuXG4gICAgLyoqXG4gICAgICogQXR0cmlidXRlIEltYWdlQ29tcG9uZW50SWQ6IFRoZSBJRCBvZiB0aGUgaW1hZ2UgY29tcG9uZW50LlxuICAgICAqL1xuICAgIHB1YmxpYyByZWFkb25seSBhdHRySW1hZ2VDb21wb25lbnRJZDogcm9zLklSZXNvbHZhYmxlO1xuXG4gICAgLyoqXG4gICAgICogUGFyYW0gc2NvcGUgLSBzY29wZSBpbiB3aGljaCB0aGlzIHJlc291cmNlIGlzIGRlZmluZWRcbiAgICAgKiBQYXJhbSBpZCAgICAtIHNjb3BlZCBpZCBvZiB0aGUgcmVzb3VyY2VcbiAgICAgKiBQYXJhbSBwcm9wcyAtIHJlc291cmNlIHByb3BlcnRpZXNcbiAgICAgKi9cbiAgICBjb25zdHJ1Y3RvcihzY29wZTogcm9zLkNvbnN0cnVjdCwgaWQ6IHN0cmluZywgcHJvcHM6IEltYWdlQ29tcG9uZW50UHJvcHMsIGVuYWJsZVJlc291cmNlUHJvcGVydHlDb25zdHJhaW50OmJvb2xlYW4gPSB0cnVlKSB7XG4gICAgICAgIHN1cGVyKHNjb3BlLCBpZCk7XG4gICAgICAgIHRoaXMuc2NvcGUgPSBzY29wZTtcbiAgICAgICAgdGhpcy5pZCA9IGlkO1xuICAgICAgICB0aGlzLnByb3BzID0gcHJvcHM7XG4gICAgICAgIHRoaXMuZW5hYmxlUmVzb3VyY2VQcm9wZXJ0eUNvbnN0cmFpbnQgPSBlbmFibGVSZXNvdXJjZVByb3BlcnR5Q29uc3RyYWludDtcblxuICAgICAgICBjb25zdCByb3NJbWFnZUNvbXBvbmVudCA9IG5ldyBSb3NJbWFnZUNvbXBvbmVudCh0aGlzLCBpZCwgIHtcbiAgICAgICAgICAgIGNvbXBvbmVudFR5cGU6IHByb3BzLmNvbXBvbmVudFR5cGUgPT09IHVuZGVmaW5lZCB8fCBwcm9wcy5jb21wb25lbnRUeXBlID09PSBudWxsID8gJ0J1aWxkJyA6IHByb3BzLmNvbXBvbmVudFR5cGUsXG4gICAgICAgICAgICBkZXNjcmlwdGlvbjogcHJvcHMuZGVzY3JpcHRpb24sXG4gICAgICAgICAgICByZXNvdXJjZUdyb3VwSWQ6IHByb3BzLnJlc291cmNlR3JvdXBJZCxcbiAgICAgICAgICAgIGNvbnRlbnQ6IHByb3BzLmNvbnRlbnQsXG4gICAgICAgICAgICBzeXN0ZW1UeXBlOiBwcm9wcy5zeXN0ZW1UeXBlID09PSB1bmRlZmluZWQgfHwgcHJvcHMuc3lzdGVtVHlwZSA9PT0gbnVsbCA/ICdMaW51eCcgOiBwcm9wcy5zeXN0ZW1UeXBlLFxuICAgICAgICAgICAgdGFnczogcHJvcHMudGFncyxcbiAgICAgICAgICAgIG5hbWU6IHByb3BzLm5hbWUsXG4gICAgICAgIH0sIGVuYWJsZVJlc291cmNlUHJvcGVydHlDb25zdHJhaW50ICYmIHRoaXMuc3RhY2suZW5hYmxlUmVzb3VyY2VQcm9wZXJ0eUNvbnN0cmFpbnQpO1xuICAgICAgICB0aGlzLnJlc291cmNlID0gcm9zSW1hZ2VDb21wb25lbnQ7XG4gICAgICAgIHRoaXMuYXR0ckltYWdlQ29tcG9uZW50SWQgPSByb3NJbWFnZUNvbXBvbmVudC5hdHRySW1hZ2VDb21wb25lbnRJZDtcbiAgICB9XG59XG4iXX0=

package/lib/imagepipeline.d.ts

@@ -0,0 +1,109 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosImagePipeline } from './ecs.generated';
+export { RosImagePipeline as ImagePipelineProperty };
+/**
+ * Properties for defining a `ImagePipeline`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-imagepipeline
+ */
+export interface ImagePipelineProps {
+    /**
+     * Property baseImage: The source image.
+     * If you set BaseImageType to IMAGE, set the BaseImage parameter to the ID of a custom image.
+     * If you set BaseImageType to IMAGE_FAMILY, set the BaseImage parameter to the name of an image family.
+     */
+    readonly baseImage: string | ros.IResolvable;
+    /**
+     * Property baseImageType: The type of the source image. Valid values:
+     * IMAGE: image
+     * IMAGE_FAMILY: image family
+     */
+    readonly baseImageType: string | ros.IResolvable;
+    /**
+     * Property addAccount: The IDs of Alibaba Cloud accounts to which to share the image that will be created based on the image template. You can specify up to 20 account IDs.
+     */
+    readonly addAccount?: Array<string | ros.IResolvable> | ros.IResolvable;
+    /**
+     * Property buildContent: The content of the image template. The content cannot exceed 16 KB in size and can contain up to 127 commands. For more information about the commands that are supported, see the "Usage notes" section of this topic.
+     */
+    readonly buildContent?: string | ros.IResolvable;
+    /**
+     * Property deleteInstanceOnFailure: Specifies whether to release the intermediate instance when the image cannot be created. Valid values:
+     * true
+     * false
+     * Default value: true.
+     * Note If the intermediate instance cannot be started, the instance is released by default.
+     */
+    readonly deleteInstanceOnFailure?: boolean | ros.IResolvable;
+    /**
+     * Property description: The description of the image template. The description must be 2 to 256 characters in length. It cannot start with http:\/\/ or https:\/\/.
+     */
+    readonly description?: string | ros.IResolvable;
+    /**
+     * Property executePipeline: Whether execute pipeline. Default value is true
+     */
+    readonly executePipeline?: boolean | ros.IResolvable;
+    /**
+     * Property imageName: The prefix of the image name. The prefix must be 2 to 64 characters in length. It must start with a letter and cannot start with http:\/\/ or https:\/\/. It can contain letters, digits, colons (:), underscores (_), periods (.), and hyphens (-).
+     * The system generates the final complete image name that consists of the specified prefix and the ID of the build task (ExecutionId) in the format of {ImageName}_{ExecutionId}.
+     */
+    readonly imageName?: string | ros.IResolvable;
+    /**
+     * Property instanceType: The instance type. You can call the  DescribeInstanceTypes  to query instance types.
+     * If you do not configure this parameter, an instance type that provides the fewest vCPUs and memory resources is automatically selected. This configuration is subject to resource availability of instance types. For example, the ecs.g6.large instance type is automatically selected. If available ecs.g6.large resources are insufficient, the ecs.g6.xlarge instance type is selected.
+     */
+    readonly instanceType?: string | ros.IResolvable;
+    /**
+     * Property internetMaxBandwidthOut: The size of the outbound public bandwidth for the intermediate instance. Unit: Mbit\/s. Valid values: 0 to 100.
+     * Default value: 0.
+     */
+    readonly internetMaxBandwidthOut?: number | ros.IResolvable;
+    /**
+     * Property name: The name of the image template. The name must be 2 to 128 characters in length. It must start with a letter and cannot start with http:\/\/ or https:\/\/. It can contain letters, digits, colons (:), underscores (_), periods (.), and hyphens (-).
+     * Note If you do not specify the Name parameter, the return value of ImagePipelineId is used.
+     */
+    readonly name?: string | ros.IResolvable;
+    /**
+     * Property resourceGroupId: The ID of the resource group.
+     */
+    readonly resourceGroupId?: string | ros.IResolvable;
+    /**
+     * Property systemDiskSize: The system disk size of the intermediate instance. Unit: GiB. Valid values: 20 to 500.
+     * Default value: 40.
+     */
+    readonly systemDiskSize?: number | ros.IResolvable;
+    /**
+     * Property tags:
+     */
+    readonly tags?: RosImagePipeline.TagsProperty[];
+    /**
+     * Property toRegionId: The IDs of regions to which you want to distribute the image that is created based on the image template. You can specify up to 20 region IDs.
+     * If you do not specify this parameter, the image is created only in the current region.
+     */
+    readonly toRegionId?: Array<string | ros.IResolvable> | ros.IResolvable;
+    /**
+     * Property vSwitchId: The ID of the vSwitch.
+     * If you do not specify this parameter, a new VPC and vSwitch are created. Make sure that the VPC quota in your account is sufficient. For more information, see Limits and quotas.
+     */
+    readonly vSwitchId?: string | ros.IResolvable;
+}
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::ECS::ImagePipeline`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosImagePipeline`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-ecs-imagepipeline
+ */
+export declare class ImagePipeline extends ros.Resource {
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: ImagePipelineProps;
+    protected enableResourcePropertyConstraint: boolean;
+    /**
+     * Attribute ImagePipelineId: The ID of the image template.
+     */
+    readonly attrImagePipelineId: 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: ImagePipelineProps, enableResourcePropertyConstraint?: boolean);
+}