@alicloud/ros-cdk-ecs 1.0.23 → 1.0.24

package/lib/command.d.ts

@@ -14,6 +14,13 @@ export interface CommandProps {
      * Property commandContent: The content of command. Content requires base64 encoding. Maximum size support 16KB.
      */
     readonly commandContent?: string | ros.IResolvable;
+    /**
+     * Property contentEncoding: The encoding mode of script content (CommandContent). Valid values (case insensitive):
+     * PlainText: The script content is not encoded, and transmitted in plaintext.
+     * Base64: base64-encoded.
+     * Default value: Base64. If the specified value of this parameter is invalid, Base64 is used by default.
+     */
+    readonly contentEncoding?: string | ros.IResolvable;
     /**
      * Property description: The description of command.
      */
@@ -27,6 +34,10 @@ export interface CommandProps {
      * Property name: The name of command.
      */
     readonly name?: string | ros.IResolvable;
+    /**
+     * Property resourceGroupId: Resource group id.
+     */
+    readonly resourceGroupId?: string | ros.IResolvable;
     /**
      * Property tags: Tags to attach to command. Max support 20 tags to add during create command. Each tag with two properties Key and Value, and Key is required.
      */

package/lib/command.js

@@ -26,8 +26,10 @@ class Command extends ros.Resource {
             commandContent: props.commandContent,
             type: props.type,
             description: props.description,
+            resourceGroupId: props.resourceGroupId,
             timeout: props.timeout,
             enableParameter: props.enableParameter,
+            contentEncoding: props.contentEncoding,
             tags: props.tags,
             name: props.name,
         }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
@@ -36,4 +38,4 @@ class Command extends ros.Resource {
     }
 }
 exports.Command = Command;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbWFuZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImNvbW1hbmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsOENBQThDO0FBQzlDLG1EQUE2QztBQUV0QixnR0FGZCwwQkFBVSxPQUVtQjtBQWtEdEM7Ozs7R0FJRztBQUNILE1BQWEsT0FBUSxTQUFRLEdBQUcsQ0FBQyxRQUFRO0lBV3JDOzs7O09BSUc7SUFDSCxZQUFZLEtBQW9CLEVBQUUsRUFBVSxFQUFFLEtBQW1CLEVBQUUsbUNBQTJDLElBQUk7UUFDOUcsS0FBSyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsQ0FBQztRQUNqQixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNuQixJQUFJLENBQUMsRUFBRSxHQUFHLEVBQUUsQ0FBQztRQUNiLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ25CLElBQUksQ0FBQyxnQ0FBZ0MsR0FBRyxnQ0FBZ0MsQ0FBQztRQUV6RSxNQUFNLFVBQVUsR0FBRyxJQUFJLDBCQUFVLENBQUMsSUFBSSxFQUFFLEVBQUUsRUFBRztZQUN6QyxVQUFVLEVBQUUsS0FBSyxDQUFDLFVBQVU7WUFDNUIsY0FBYyxFQUFFLEtBQUssQ0FBQyxjQUFjO1lBQ3BDLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSTtZQUNoQixXQUFXLEVBQUUsS0FBSyxDQUFDLFdBQVc7WUFDOUIsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPO1lBQ3RCLGVBQWUsRUFBRSxLQUFLLENBQUMsZUFBZTtZQUN0QyxJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUk7WUFDaEIsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJO1NBQ25CLEVBQUUsZ0NBQWdDLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQyxnQ0FBZ0MsQ0FBQyxDQUFDO1FBQ3BGLElBQUksQ0FBQyxRQUFRLEdBQUcsVUFBVSxDQUFDO1FBQzNCLElBQUksQ0FBQyxhQUFhLEdBQUcsVUFBVSxDQUFDLGFBQWEsQ0FBQztJQUNsRCxDQUFDO0NBQ0o7QUFwQ0QsMEJBb0NDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgcm9zIGZyb20gJ0BhbGljbG91ZC9yb3MtY2RrLWNvcmUnO1xuaW1wb3J0IHsgUm9zQ29tbWFuZCB9IGZyb20gJy4vZWNzLmdlbmVyYXRlZCc7XG4vLyBHZW5lcmF0ZWQgZnJvbSB0aGUgQWxpQ2xvdWQgUk9TIFJlc291cmNlIFNwZWNpZmljYXRpb25cbmV4cG9ydCB7IFJvc0NvbW1hbmQgYXMgQ29tbWFuZFByb3BlcnR5IH07XG5cbi8qKlxuICogUHJvcGVydGllcyBmb3IgZGVmaW5pbmcgYSBgQ29tbWFuZGAuXG4gKiBTZWUgaHR0cHM6Ly93d3cuYWxpYmFiYWNsb3VkLmNvbS9oZWxwL3Jvcy9kZXZlbG9wZXItcmVmZXJlbmNlL2FsaXl1bi1lY3MtY29tbWFuZFxuICovXG5leHBvcnQgaW50ZXJmYWNlIENvbW1hbmRQcm9wcyB7XG5cbiAgICAvKipcbiAgICAgKiBQcm9wZXJ0eSB0eXBlOiBUaGUgdHlwZSBvZiBjb21tYW5kLlxuICAgICAqL1xuICAgIHJlYWRvbmx5IHR5cGU6IHN0cmluZyB8IHJvcy5JUmVzb2x2YWJsZTtcblxuICAgIC8qKlxuICAgICAqIFByb3BlcnR5IGNvbW1hbmRDb250ZW50OiBUaGUgY29udGVudCBvZiBjb21tYW5kLiBDb250ZW50IHJlcXVpcmVzIGJhc2U2NCBlbmNvZGluZy4gTWF4aW11bSBzaXplIHN1cHBvcnQgMTZLQi5cbiAgICAgKi9cbiAgICByZWFkb25seSBjb21tYW5kQ29udGVudD86IHN0cmluZyB8IHJvcy5JUmVzb2x2YWJsZTtcblxuICAgIC8qKlxuICAgICAqIFByb3BlcnR5IGRlc2NyaXB0aW9uOiBUaGUgZGVzY3JpcHRpb24gb2YgY29tbWFuZC5cbiAgICAgKi9cbiAgICByZWFkb25seSBkZXNjcmlwdGlvbj86IHN0cmluZyB8IHJvcy5JUmVzb2x2YWJsZTtcblxuICAgIC8qKlxuICAgICAqIFByb3BlcnR5IGVuYWJsZVBhcmFtZXRlcjogU3BlY2lmaWVzIHdoZXRoZXIgdGhlIHNjcmlwdCBjb250YWlucyBjdXN0b20gcGFyYW1ldGVycy5cbiAgICAgKiBEZWZhdWx0IHZhbHVlOiBmYWxzZVxuICAgICAqL1xuICAgIHJlYWRvbmx5IGVuYWJsZVBhcmFtZXRlcj86IGJvb2xlYW4gfCByb3MuSVJlc29sdmFibGU7XG5cbiAgICAvKipcbiAgICAgKiBQcm9wZXJ0eSBuYW1lOiBUaGUgbmFtZSBvZiBjb21tYW5kLlxuICAgICAqL1xuICAgIHJlYWRvbmx5IG5hbWU/OiBzdHJpbmcgfCByb3MuSVJlc29sdmFibGU7XG5cbiAgICAvKipcbiAgICAgKiBQcm9wZXJ0eSB0YWdzOiBUYWdzIHRvIGF0dGFjaCB0byBjb21tYW5kLiBNYXggc3VwcG9ydCAyMCB0YWdzIHRvIGFkZCBkdXJpbmcgY3JlYXRlIGNvbW1hbmQuIEVhY2ggdGFnIHdpdGggdHdvIHByb3BlcnRpZXMgS2V5IGFuZCBWYWx1ZSwgYW5kIEtleSBpcyByZXF1aXJlZC5cbiAgICAgKi9cbiAgICByZWFkb25seSB0YWdzPzogUm9zQ29tbWFuZC5UYWdzUHJvcGVydHlbXTtcblxuICAgIC8qKlxuICAgICAqIFByb3BlcnR5IHRpbWVvdXQ6IFRvdGFsIHRpbWVvdXQgd2hlbiB0aGUgY29tbWFuZCBpcyBleGVjdXRlZCBpbiB0aGUgaW5zdGFuY2UuIElucHV0IHRoZSB0aW1lIHVuaXQgYXMgc2Vjb25kLiBEZWZhdWx0IGlzIDYwcy5cbiAgICAgKi9cbiAgICByZWFkb25seSB0aW1lb3V0PzogbnVtYmVyIHwgcm9zLklSZXNvbHZhYmxlO1xuXG4gICAgLyoqXG4gICAgICogUHJvcGVydHkgd29ya2luZ0RpcjogVGhlIHBhdGggd2hlcmUgY29tbWFuZCB3aWxsIGJlIGV4ZWN1dGVkIGluIHRoZSBpbnN0YW5jZS5cbiAgICAgKi9cbiAgICByZWFkb25seSB3b3JraW5nRGlyPzogc3RyaW5nIHwgcm9zLklSZXNvbHZhYmxlO1xufVxuXG4vKipcbiAqIFRoaXMgY2xhc3MgZW5jYXBzdWxhdGVzIGFuZCBleHRlbmRzIHRoZSBST1MgcmVzb3VyY2UgdHlwZSBgQUxJWVVOOjpFQ1M6OkNvbW1hbmRgLCB3aGljaCBpcyB1c2VkIHRvIGNyZWF0ZSBhIENsb3VkIEFzc2lzdGFudCBjb21tYW5kLlxuICogQE5vdGUgVGhpcyBjbGFzcyBtYXkgaGF2ZSBzb21lIG5ldyBmdW5jdGlvbnMgdG8gZmFjaWxpdGF0ZSBkZXZlbG9wbWVudCwgc28gaXQgaXMgcmVjb21tZW5kZWQgdG8gdXNlIHRoaXMgY2xhc3MgaW5zdGVhZCBvZiBgUm9zQ29tbWFuZGBmb3IgYSBtb3JlIGNvbnZlbmllbnQgZGV2ZWxvcG1lbnQgZXhwZXJpZW5jZS5cbiAqIFNlZSBodHRwczovL3d3dy5hbGliYWJhY2xvdWQuY29tL2hlbHAvcm9zL2RldmVsb3Blci1yZWZlcmVuY2UvYWxpeXVuLWVjcy1jb21tYW5kXG4gKi9cbmV4cG9ydCBjbGFzcyBDb21tYW5kIGV4dGVuZHMgcm9zLlJlc291cmNlIHtcbiAgICBwcm90ZWN0ZWQgc2NvcGU6IHJvcy5Db25zdHJ1Y3Q7XG4gICAgcHJvdGVjdGVkIGlkOiBzdHJpbmc7XG4gICAgcHJvdGVjdGVkIHByb3BzOiBDb21tYW5kUHJvcHM7XG4gICAgcHJvdGVjdGVkIGVuYWJsZVJlc291cmNlUHJvcGVydHlDb25zdHJhaW50OiBib29sZWFuO1xuXG4gICAgLyoqXG4gICAgICogQXR0cmlidXRlIENvbW1hbmRJZDogVGhlIGlkIG9mIGNvbW1hbmQgY3JlYXRlZC5cbiAgICAgKi9cbiAgICBwdWJsaWMgcmVhZG9ubHkgYXR0ckNvbW1hbmRJZDogcm9zLklSZXNvbHZhYmxlO1xuXG4gICAgLyoqXG4gICAgICogUGFyYW0gc2NvcGUgLSBzY29wZSBpbiB3aGljaCB0aGlzIHJlc291cmNlIGlzIGRlZmluZWRcbiAgICAgKiBQYXJhbSBpZCAgICAtIHNjb3BlZCBpZCBvZiB0aGUgcmVzb3VyY2VcbiAgICAgKiBQYXJhbSBwcm9wcyAtIHJlc291cmNlIHByb3BlcnRpZXNcbiAgICAgKi9cbiAgICBjb25zdHJ1Y3RvcihzY29wZTogcm9zLkNvbnN0cnVjdCwgaWQ6IHN0cmluZywgcHJvcHM6IENvbW1hbmRQcm9wcywgZW5hYmxlUmVzb3VyY2VQcm9wZXJ0eUNvbnN0cmFpbnQ6Ym9vbGVhbiA9IHRydWUpIHtcbiAgICAgICAgc3VwZXIoc2NvcGUsIGlkKTtcbiAgICAgICAgdGhpcy5zY29wZSA9IHNjb3BlO1xuICAgICAgICB0aGlzLmlkID0gaWQ7XG4gICAgICAgIHRoaXMucHJvcHMgPSBwcm9wcztcbiAgICAgICAgdGhpcy5lbmFibGVSZXNvdXJjZVByb3BlcnR5Q29uc3RyYWludCA9IGVuYWJsZVJlc291cmNlUHJvcGVydHlDb25zdHJhaW50O1xuXG4gICAgICAgIGNvbnN0IHJvc0NvbW1hbmQgPSBuZXcgUm9zQ29tbWFuZCh0aGlzLCBpZCwgIHtcbiAgICAgICAgICAgIHdvcmtpbmdEaXI6IHByb3BzLndvcmtpbmdEaXIsXG4gICAgICAgICAgICBjb21tYW5kQ29udGVudDogcHJvcHMuY29tbWFuZENvbnRlbnQsXG4gICAgICAgICAgICB0eXBlOiBwcm9wcy50eXBlLFxuICAgICAgICAgICAgZGVzY3JpcHRpb246IHByb3BzLmRlc2NyaXB0aW9uLFxuICAgICAgICAgICAgdGltZW91dDogcHJvcHMudGltZW91dCxcbiAgICAgICAgICAgIGVuYWJsZVBhcmFtZXRlcjogcHJvcHMuZW5hYmxlUGFyYW1ldGVyLFxuICAgICAgICAgICAgdGFnczogcHJvcHMudGFncyxcbiAgICAgICAgICAgIG5hbWU6IHByb3BzLm5hbWUsXG4gICAgICAgIH0sIGVuYWJsZVJlc291cmNlUHJvcGVydHlDb25zdHJhaW50ICYmIHRoaXMuc3RhY2suZW5hYmxlUmVzb3VyY2VQcm9wZXJ0eUNvbnN0cmFpbnQpO1xuICAgICAgICB0aGlzLnJlc291cmNlID0gcm9zQ29tbWFuZDtcbiAgICAgICAgdGhpcy5hdHRyQ29tbWFuZElkID0gcm9zQ29tbWFuZC5hdHRyQ29tbWFuZElkO1xuICAgIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/datasource/autosnapshotpolicy.d.ts

@@ -0,0 +1,68 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosAutoSnapshotPolicy } from './ecs.generated';
+export { RosAutoSnapshotPolicy as AutoSnapshotPolicyProperty };
+/**
+ * Properties for defining a `AutoSnapshotPolicy`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ecs-autosnapshotpolicy
+ */
+export interface AutoSnapshotPolicyProps {
+    /**
+     * Property autoSnapshotPolicyId: The name of the automatic snapshot policy.
+     */
+    readonly autoSnapshotPolicyId: string | ros.IResolvable;
+}
+/**
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::ECS::AutoSnapshotPolicy`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosAutoSnapshotPolicy`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ecs-autosnapshotpolicy
+ */
+export declare class AutoSnapshotPolicy extends ros.Resource {
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: AutoSnapshotPolicyProps;
+    protected enableResourcePropertyConstraint: boolean;
+    /**
+     * Attribute AutoSnapshotPolicyName: Name of the automatic snapshot policy.
+     */
+    readonly attrAutoSnapshotPolicyName: ros.IResolvable;
+    /**
+     * Attribute CreateTime: The time when the automatic snapshot policy was created. The time follows the ISO 8601 standard in the yyyy-MM-ddThh:mm:ssZ format. The time is displayed in UTC.
+     */
+    readonly attrCreateTime: ros.IResolvable;
+    /**
+     * Attribute DiskNums: Number of cloud disks with this policy enabled.
+     */
+    readonly attrDiskNums: ros.IResolvable;
+    /**
+     * Attribute RepeatWeekdays: The days of the week on which to create automatic snapshots. Valid values: 1 to 7, which correspond to the days of the week. 1 indicates Monday. One or more days can be specified.
+     */
+    readonly attrRepeatWeekdays: ros.IResolvable;
+    /**
+     * Attribute ResourceGroupId: The ID of the resource group.
+     */
+    readonly attrResourceGroupId: ros.IResolvable;
+    /**
+     * Attribute RetentionDays: The retention period of the automatic snapshot. Unit: days. Valid values:
+- -1: The automatic snapshot is retained until it is deleted.
+- 1 to 65536: The automatic snapshot is retained for the specified number of days.
+     */
+    readonly attrRetentionDays: ros.IResolvable;
+    /**
+     * Attribute Tags: The tags of the automatic snapshot policy.
+     */
+    readonly attrTags: ros.IResolvable;
+    /**
+     * Attribute TimePoints: The time when the automatic snapshot policy was created. The time follows the ISO 8601 standard in the yyyy-MM-ddThh:mm:ssZ format. The time is displayed in UTC.
+     */
+    readonly attrTimePoints: ros.IResolvable;
+    /**
+     * Attribute VolumeNums: The number of extended volumes to which the automatic snapshot policy is applied.
+     */
+    readonly attrVolumeNums: 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: AutoSnapshotPolicyProps, enableResourcePropertyConstraint?: boolean);
+}

package/lib/datasource/autosnapshotpolicy.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoSnapshotPolicy = exports.AutoSnapshotPolicyProperty = void 0;
+const ros = require("@alicloud/ros-cdk-core");
+const ecs_generated_1 = require("./ecs.generated");
+Object.defineProperty(exports, "AutoSnapshotPolicyProperty", { enumerable: true, get: function () { return ecs_generated_1.RosAutoSnapshotPolicy; } });
+/**
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::ECS::AutoSnapshotPolicy`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosAutoSnapshotPolicy`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ecs-autosnapshotpolicy
+ */
+class AutoSnapshotPolicy 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 rosAutoSnapshotPolicy = new ecs_generated_1.RosAutoSnapshotPolicy(this, id, {
+            autoSnapshotPolicyId: props.autoSnapshotPolicyId,
+        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
+        this.resource = rosAutoSnapshotPolicy;
+        this.attrAutoSnapshotPolicyName = rosAutoSnapshotPolicy.attrAutoSnapshotPolicyName;
+        this.attrCreateTime = rosAutoSnapshotPolicy.attrCreateTime;
+        this.attrDiskNums = rosAutoSnapshotPolicy.attrDiskNums;
+        this.attrRepeatWeekdays = rosAutoSnapshotPolicy.attrRepeatWeekdays;
+        this.attrResourceGroupId = rosAutoSnapshotPolicy.attrResourceGroupId;
+        this.attrRetentionDays = rosAutoSnapshotPolicy.attrRetentionDays;
+        this.attrTags = rosAutoSnapshotPolicy.attrTags;
+        this.attrTimePoints = rosAutoSnapshotPolicy.attrTimePoints;
+        this.attrVolumeNums = rosAutoSnapshotPolicy.attrVolumeNums;
+    }
+}
+exports.AutoSnapshotPolicy = AutoSnapshotPolicy;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/datasource/command.d.ts

@@ -0,0 +1,74 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosCommand } from './ecs.generated';
+export { RosCommand as CommandProperty };
+/**
+ * Properties for defining a `Command`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ecs-command
+ */
+export interface CommandProps {
+    /**
+     * Property commandId: Command ID.
+     */
+    readonly commandId: string | ros.IResolvable;
+}
+/**
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::ECS::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/datasource-ecs-command
+ */
+export declare class Command extends ros.Resource {
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: CommandProps;
+    protected enableResourcePropertyConstraint: boolean;
+    /**
+     * Attribute CommandContent: Command content, encoded in Base64 and transmitted.
+     */
+    readonly attrCommandContent: ros.IResolvable;
+    /**
+     * Attribute CommandId: Command ID.
+     */
+    readonly attrCommandId: ros.IResolvable;
+    /**
+     * Attribute CommandName: Command name.
+     */
+    readonly attrCommandName: ros.IResolvable;
+    /**
+     * Attribute CreateTime: Command creation time.
+     */
+    readonly attrCreateTime: ros.IResolvable;
+    /**
+     * Attribute Description: Command description.
+     */
+    readonly attrDescription: ros.IResolvable;
+    /**
+     * Attribute EnableParameter: Whether to use parameters.
+     */
+    readonly attrEnableParameter: ros.IResolvable;
+    /**
+     * Attribute ParameterNames: Parameter name.
+     */
+    readonly attrParameterNames: ros.IResolvable;
+    /**
+     * Attribute Tags: The label information of the command.
+     */
+    readonly attrTags: ros.IResolvable;
+    /**
+     * Attribute Timeout: Timeout.
+     */
+    readonly attrTimeout: ros.IResolvable;
+    /**
+     * Attribute Type: Command type.
+     */
+    readonly attrType: ros.IResolvable;
+    /**
+     * Attribute WorkingDir: Execution path.
+     */
+    readonly attrWorkingDir: 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: CommandProps, enableResourcePropertyConstraint?: boolean);
+}

package/lib/datasource/command.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = exports.CommandProperty = void 0;
+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; } });
+/**
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::ECS::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/datasource-ecs-command
+ */
+class Command 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 rosCommand = new ecs_generated_1.RosCommand(this, id, {
+            commandId: props.commandId,
+        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
+        this.resource = rosCommand;
+        this.attrCommandContent = rosCommand.attrCommandContent;
+        this.attrCommandId = rosCommand.attrCommandId;
+        this.attrCommandName = rosCommand.attrCommandName;
+        this.attrCreateTime = rosCommand.attrCreateTime;
+        this.attrDescription = rosCommand.attrDescription;
+        this.attrEnableParameter = rosCommand.attrEnableParameter;
+        this.attrParameterNames = rosCommand.attrParameterNames;
+        this.attrTags = rosCommand.attrTags;
+        this.attrTimeout = rosCommand.attrTimeout;
+        this.attrType = rosCommand.attrType;
+        this.attrWorkingDir = rosCommand.attrWorkingDir;
+    }
+}
+exports.Command = Command;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/datasource/disk.d.ts

@@ -0,0 +1,186 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosDisk } from './ecs.generated';
+export { RosDisk as DiskProperty };
+/**
+ * Properties for defining a `Disk`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ecs-disk
+ */
+export interface DiskProps {
+    /**
+     * Property diskId: The disk id.
+     */
+    readonly diskId: string | ros.IResolvable;
+}
+/**
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::ECS::Disk`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosDisk`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ecs-disk
+ */
+export declare class Disk extends ros.Resource {
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: DiskProps;
+    protected enableResourcePropertyConstraint: boolean;
+    /**
+     * Attribute AttachedTime: The attached time.
+     */
+    readonly attrAttachedTime: ros.IResolvable;
+    /**
+     * Attribute AutoSnapshotPolicyId: Automatic snapshot policy ID.
+     */
+    readonly attrAutoSnapshotPolicyId: ros.IResolvable;
+    /**
+     * Attribute BurstingEnabled: Does the data disk turn on Burst (performance Burst).
+     */
+    readonly attrBurstingEnabled: ros.IResolvable;
+    /**
+     * Attribute Category: Disk type.
+     */
+    readonly attrCategory: ros.IResolvable;
+    /**
+     * Attribute CreateTime: The creation time.
+     */
+    readonly attrCreateTime: ros.IResolvable;
+    /**
+     * Attribute DeleteAutoSnapshot: Whether to delete automatic snapshots at the same time.
+     */
+    readonly attrDeleteAutoSnapshot: ros.IResolvable;
+    /**
+     * Attribute DeleteWithInstance: Whether to release with the instance.
+     */
+    readonly attrDeleteWithInstance: ros.IResolvable;
+    /**
+     * Attribute Description: The description.
+     */
+    readonly attrDescription: ros.IResolvable;
+    /**
+     * Attribute DetachedTime: Unloading time.
+     */
+    readonly attrDetachedTime: ros.IResolvable;
+    /**
+     * Attribute Device: Cloud disk or the device name of the mounted instance on the site.
+     */
+    readonly attrDevice: ros.IResolvable;
+    /**
+     * Attribute DiskId: The disk id.
+     */
+    readonly attrDiskId: ros.IResolvable;
+    /**
+     * Attribute DiskName: The disk name.
+     */
+    readonly attrDiskName: ros.IResolvable;
+    /**
+     * Attribute EnableAutoSnapshot: Whether the disk implements an automatic snapshot policy.
+     */
+    readonly attrEnableAutoSnapshot: ros.IResolvable;
+    /**
+     * Attribute EnableAutomatedSnapshotPolicy: Whether the disk implements an automatic snapshot policy.
+     */
+    readonly attrEnableAutomatedSnapshotPolicy: ros.IResolvable;
+    /**
+     * Attribute Encrypted: Whether the disk is encrypted.
+     */
+    readonly attrEncrypted: ros.IResolvable;
+    /**
+     * Attribute ExpiredTime: The expiration time of a monthly disk.
+     */
+    readonly attrExpiredTime: ros.IResolvable;
+    /**
+     * Attribute ImageId: The image id.
+     */
+    readonly attrImageId: ros.IResolvable;
+    /**
+     * Attribute InstanceId: The instance id.
+     */
+    readonly attrInstanceId: ros.IResolvable;
+    /**
+     * Attribute Iops: Number of read/write (I/O) operations per second.
+     */
+    readonly attrIops: ros.IResolvable;
+    /**
+     * Attribute IopsRead: Number of reads per second.
+     */
+    readonly attrIopsRead: ros.IResolvable;
+    /**
+     * Attribute IopsWrite: Number of writes per second.
+     */
+    readonly attrIopsWrite: ros.IResolvable;
+    /**
+     * Attribute KmsKeyId: The KMS keyId.
+     */
+    readonly attrKmsKeyId: ros.IResolvable;
+    /**
+     * Attribute MountInstanceNum: Number of instances mounted on shared storage.
+     */
+    readonly attrMountInstanceNum: ros.IResolvable;
+    /**
+     * Attribute MountInstances: Disk mount instances.
+     */
+    readonly attrMountInstances: ros.IResolvable;
+    /**
+     * Attribute MultiAttach: Whether to enable the multi-Mount feature.
+     */
+    readonly attrMultiAttach: ros.IResolvable;
+    /**
+     * Attribute OperationLocks: Resource locking information.
+     */
+    readonly attrOperationLocks: ros.IResolvable;
+    /**
+     * Attribute PaymentType: Payment method for disk.
+     */
+    readonly attrPaymentType: ros.IResolvable;
+    /**
+     * Attribute PerformanceLevel: Performance levels of ESSD cloud disk.
+     */
+    readonly attrPerformanceLevel: ros.IResolvable;
+    /**
+     * Attribute Portable: Whether the disk is unmountable.
+     */
+    readonly attrPortable: ros.IResolvable;
+    /**
+     * Attribute ProductCode: The product logo of the cloud market.
+     */
+    readonly attrProductCode: ros.IResolvable;
+    /**
+     * Attribute ProvisionedIops: The preconfigured read and write IOPS of the ESSD AutoPL cloud disk. Possible values: 0 ~ min{50,000, 1000 * capacity-baseline performance}.
+     */
+    readonly attrProvisionedIops: ros.IResolvable;
+    /**
+     * Attribute ResourceGroupId: The resource group id.
+     */
+    readonly attrResourceGroupId: ros.IResolvable;
+    /**
+     * Attribute Size: Disk size.
+     */
+    readonly attrSize: ros.IResolvable;
+    /**
+     * Attribute SnapshotId: The source snapshot id.
+     */
+    readonly attrSnapshotId: ros.IResolvable;
+    /**
+     * Attribute StorageClusterId: The ID of the dedicated block storage cluster. If you need to create a cloud disk in the specified dedicated block storage cluster, specify this parameter.
+     */
+    readonly attrStorageClusterId: ros.IResolvable;
+    /**
+     * Attribute StorageSetId: The ID of the Save set.
+     */
+    readonly attrStorageSetId: ros.IResolvable;
+    /**
+     * Attribute StorageSetPartitionNumber: Number of Save set partitions. Value range: greater than or equal to 2. The maximum value cannot exceed the equity quota limit displayed after calling.
+     */
+    readonly attrStorageSetPartitionNumber: ros.IResolvable;
+    /**
+     * Attribute Tags: The tags.
+     */
+    readonly attrTags: ros.IResolvable;
+    /**
+     * Attribute ZoneId: ID of the free zone to which the disk belongs.
+     */
+    readonly attrZoneId: 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: DiskProps, enableResourcePropertyConstraint?: boolean);
+}

package/lib/datasource/disk.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Disk = exports.DiskProperty = void 0;
+const ros = require("@alicloud/ros-cdk-core");
+const ecs_generated_1 = require("./ecs.generated");
+Object.defineProperty(exports, "DiskProperty", { enumerable: true, get: function () { return ecs_generated_1.RosDisk; } });
+/**
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::ECS::Disk`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosDisk`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ecs-disk
+ */
+class Disk 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 rosDisk = new ecs_generated_1.RosDisk(this, id, {
+            diskId: props.diskId,
+        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
+        this.resource = rosDisk;
+        this.attrAttachedTime = rosDisk.attrAttachedTime;
+        this.attrAutoSnapshotPolicyId = rosDisk.attrAutoSnapshotPolicyId;
+        this.attrBurstingEnabled = rosDisk.attrBurstingEnabled;
+        this.attrCategory = rosDisk.attrCategory;
+        this.attrCreateTime = rosDisk.attrCreateTime;
+        this.attrDeleteAutoSnapshot = rosDisk.attrDeleteAutoSnapshot;
+        this.attrDeleteWithInstance = rosDisk.attrDeleteWithInstance;
+        this.attrDescription = rosDisk.attrDescription;
+        this.attrDetachedTime = rosDisk.attrDetachedTime;
+        this.attrDevice = rosDisk.attrDevice;
+        this.attrDiskId = rosDisk.attrDiskId;
+        this.attrDiskName = rosDisk.attrDiskName;
+        this.attrEnableAutoSnapshot = rosDisk.attrEnableAutoSnapshot;
+        this.attrEnableAutomatedSnapshotPolicy = rosDisk.attrEnableAutomatedSnapshotPolicy;
+        this.attrEncrypted = rosDisk.attrEncrypted;
+        this.attrExpiredTime = rosDisk.attrExpiredTime;
+        this.attrImageId = rosDisk.attrImageId;
+        this.attrInstanceId = rosDisk.attrInstanceId;
+        this.attrIops = rosDisk.attrIops;
+        this.attrIopsRead = rosDisk.attrIopsRead;
+        this.attrIopsWrite = rosDisk.attrIopsWrite;
+        this.attrKmsKeyId = rosDisk.attrKmsKeyId;
+        this.attrMountInstanceNum = rosDisk.attrMountInstanceNum;
+        this.attrMountInstances = rosDisk.attrMountInstances;
+        this.attrMultiAttach = rosDisk.attrMultiAttach;
+        this.attrOperationLocks = rosDisk.attrOperationLocks;
+        this.attrPaymentType = rosDisk.attrPaymentType;
+        this.attrPerformanceLevel = rosDisk.attrPerformanceLevel;
+        this.attrPortable = rosDisk.attrPortable;
+        this.attrProductCode = rosDisk.attrProductCode;
+        this.attrProvisionedIops = rosDisk.attrProvisionedIops;
+        this.attrResourceGroupId = rosDisk.attrResourceGroupId;
+        this.attrSize = rosDisk.attrSize;
+        this.attrSnapshotId = rosDisk.attrSnapshotId;
+        this.attrStorageClusterId = rosDisk.attrStorageClusterId;
+        this.attrStorageSetId = rosDisk.attrStorageSetId;
+        this.attrStorageSetPartitionNumber = rosDisk.attrStorageSetPartitionNumber;
+        this.attrTags = rosDisk.attrTags;
+        this.attrZoneId = rosDisk.attrZoneId;
+    }
+}
+exports.Disk = Disk;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"disk.js","sourceRoot":"","sources":["disk.ts"],"names":[],"mappings":";;;AAAA,8CAA8C;AAC9C,mDAA0C;AAEtB,6FAFX,uBAAO,OAEgB;AAchC;;;;GAIG;AACH,MAAa,IAAK,SAAQ,GAAG,CAAC,QAAQ;IAyMlC;;;;OAIG;IACH,YAAY,KAAoB,EAAE,EAAU,EAAE,KAAgB,EAAE,mCAA2C,IAAI;QAC3G,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,OAAO,GAAG,IAAI,uBAAO,CAAC,IAAI,EAAE,EAAE,EAAG;YACnC,MAAM,EAAE,KAAK,CAAC,MAAM;SACvB,EAAE,gCAAgC,IAAI,IAAI,CAAC,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpF,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;QACjD,IAAI,CAAC,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC;QACjE,IAAI,CAAC,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;QACvD,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;QACzC,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;QAC7C,IAAI,CAAC,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC;QAC7D,IAAI,CAAC,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC;QAC7D,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;QAC/C,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;QACjD,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;QACrC,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;QACrC,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;QACzC,IAAI,CAAC,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC;QAC7D,IAAI,CAAC,iCAAiC,GAAG,OAAO,CAAC,iCAAiC,CAAC;QACnF,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;QAC3C,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;QAC/C,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;QACvC,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;QAC7C,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QACjC,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;QACzC,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;QAC3C,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;QACzC,IAAI,CAAC,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC;QACzD,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC;QACrD,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;QAC/C,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC;QACrD,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;QAC/C,IAAI,CAAC,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC;QACzD,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;QACzC,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;QAC/C,IAAI,CAAC,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;QACvD,IAAI,CAAC,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;QACvD,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QACjC,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;QAC7C,IAAI,CAAC,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC;QACzD,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;QACjD,IAAI,CAAC,6BAA6B,GAAG,OAAO,CAAC,6BAA6B,CAAC;QAC3E,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QACjC,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IACzC,CAAC;CACJ;AAjQD,oBAiQC","sourcesContent":["import * as ros from '@alicloud/ros-cdk-core';\nimport { RosDisk } from './ecs.generated';\n// Generated from the AliCloud ROS Resource Specification\nexport { RosDisk as DiskProperty };\n\n/**\n * Properties for defining a `Disk`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ecs-disk\n */\nexport interface DiskProps {\n\n    /**\n     * Property diskId: The disk id.\n     */\n    readonly diskId: string | ros.IResolvable;\n}\n\n/**\n * This class encapsulates and extends the ROS resource type `DATASOURCE::ECS::Disk`.\n * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosDisk`for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ecs-disk\n */\nexport class Disk extends ros.Resource {\n    protected scope: ros.Construct;\n    protected id: string;\n    protected props: DiskProps;\n    protected enableResourcePropertyConstraint: boolean;\n\n    /**\n     * Attribute AttachedTime: The attached time.\n     */\n    public readonly attrAttachedTime: ros.IResolvable;\n\n    /**\n     * Attribute AutoSnapshotPolicyId: Automatic snapshot policy ID.\n     */\n    public readonly attrAutoSnapshotPolicyId: ros.IResolvable;\n\n    /**\n     * Attribute BurstingEnabled: Does the data disk turn on Burst (performance Burst).\n     */\n    public readonly attrBurstingEnabled: ros.IResolvable;\n\n    /**\n     * Attribute Category: Disk type.\n     */\n    public readonly attrCategory: ros.IResolvable;\n\n    /**\n     * Attribute CreateTime: The creation time.\n     */\n    public readonly attrCreateTime: ros.IResolvable;\n\n    /**\n     * Attribute DeleteAutoSnapshot: Whether to delete automatic snapshots at the same time.\n     */\n    public readonly attrDeleteAutoSnapshot: ros.IResolvable;\n\n    /**\n     * Attribute DeleteWithInstance: Whether to release with the instance.\n     */\n    public readonly attrDeleteWithInstance: ros.IResolvable;\n\n    /**\n     * Attribute Description: The description.\n     */\n    public readonly attrDescription: ros.IResolvable;\n\n    /**\n     * Attribute DetachedTime: Unloading time.\n     */\n    public readonly attrDetachedTime: ros.IResolvable;\n\n    /**\n     * Attribute Device: Cloud disk or the device name of the mounted instance on the site.\n     */\n    public readonly attrDevice: ros.IResolvable;\n\n    /**\n     * Attribute DiskId: The disk id.\n     */\n    public readonly attrDiskId: ros.IResolvable;\n\n    /**\n     * Attribute DiskName: The disk name.\n     */\n    public readonly attrDiskName: ros.IResolvable;\n\n    /**\n     * Attribute EnableAutoSnapshot: Whether the disk implements an automatic snapshot policy.\n     */\n    public readonly attrEnableAutoSnapshot: ros.IResolvable;\n\n    /**\n     * Attribute EnableAutomatedSnapshotPolicy: Whether the disk implements an automatic snapshot policy.\n     */\n    public readonly attrEnableAutomatedSnapshotPolicy: ros.IResolvable;\n\n    /**\n     * Attribute Encrypted: Whether the disk is encrypted.\n     */\n    public readonly attrEncrypted: ros.IResolvable;\n\n    /**\n     * Attribute ExpiredTime: The expiration time of a monthly disk.\n     */\n    public readonly attrExpiredTime: ros.IResolvable;\n\n    /**\n     * Attribute ImageId: The image id.\n     */\n    public readonly attrImageId: ros.IResolvable;\n\n    /**\n     * Attribute InstanceId: The instance id.\n     */\n    public readonly attrInstanceId: ros.IResolvable;\n\n    /**\n     * Attribute Iops: Number of read/write (I/O) operations per second.\n     */\n    public readonly attrIops: ros.IResolvable;\n\n    /**\n     * Attribute IopsRead: Number of reads per second.\n     */\n    public readonly attrIopsRead: ros.IResolvable;\n\n    /**\n     * Attribute IopsWrite: Number of writes per second.\n     */\n    public readonly attrIopsWrite: ros.IResolvable;\n\n    /**\n     * Attribute KmsKeyId: The KMS keyId.\n     */\n    public readonly attrKmsKeyId: ros.IResolvable;\n\n    /**\n     * Attribute MountInstanceNum: Number of instances mounted on shared storage.\n     */\n    public readonly attrMountInstanceNum: ros.IResolvable;\n\n    /**\n     * Attribute MountInstances: Disk mount instances.\n     */\n    public readonly attrMountInstances: ros.IResolvable;\n\n    /**\n     * Attribute MultiAttach: Whether to enable the multi-Mount feature.\n     */\n    public readonly attrMultiAttach: ros.IResolvable;\n\n    /**\n     * Attribute OperationLocks: Resource locking information.\n     */\n    public readonly attrOperationLocks: ros.IResolvable;\n\n    /**\n     * Attribute PaymentType: Payment method for disk.\n     */\n    public readonly attrPaymentType: ros.IResolvable;\n\n    /**\n     * Attribute PerformanceLevel: Performance levels of ESSD cloud disk.\n     */\n    public readonly attrPerformanceLevel: ros.IResolvable;\n\n    /**\n     * Attribute Portable: Whether the disk is unmountable.\n     */\n    public readonly attrPortable: ros.IResolvable;\n\n    /**\n     * Attribute ProductCode: The product logo of the cloud market.\n     */\n    public readonly attrProductCode: ros.IResolvable;\n\n    /**\n     * Attribute ProvisionedIops: The preconfigured read and write IOPS of the ESSD AutoPL cloud disk. Possible values: 0 ~ min{50,000, 1000 * capacity-baseline performance}.\n     */\n    public readonly attrProvisionedIops: ros.IResolvable;\n\n    /**\n     * Attribute ResourceGroupId: The resource group id.\n     */\n    public readonly attrResourceGroupId: ros.IResolvable;\n\n    /**\n     * Attribute Size: Disk size.\n     */\n    public readonly attrSize: ros.IResolvable;\n\n    /**\n     * Attribute SnapshotId: The source snapshot id.\n     */\n    public readonly attrSnapshotId: ros.IResolvable;\n\n    /**\n     * Attribute StorageClusterId: The ID of the dedicated block storage cluster. If you need to create a cloud disk in the specified dedicated block storage cluster, specify this parameter.\n     */\n    public readonly attrStorageClusterId: ros.IResolvable;\n\n    /**\n     * Attribute StorageSetId: The ID of the Save set.\n     */\n    public readonly attrStorageSetId: ros.IResolvable;\n\n    /**\n     * Attribute StorageSetPartitionNumber: Number of Save set partitions. Value range: greater than or equal to 2. The maximum value cannot exceed the equity quota limit displayed after calling.\n     */\n    public readonly attrStorageSetPartitionNumber: ros.IResolvable;\n\n    /**\n     * Attribute Tags: The tags.\n     */\n    public readonly attrTags: ros.IResolvable;\n\n    /**\n     * Attribute ZoneId: ID of the free zone to which the disk belongs.\n     */\n    public readonly attrZoneId: 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: DiskProps, 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 rosDisk = new RosDisk(this, id,  {\n            diskId: props.diskId,\n        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);\n        this.resource = rosDisk;\n        this.attrAttachedTime = rosDisk.attrAttachedTime;\n        this.attrAutoSnapshotPolicyId = rosDisk.attrAutoSnapshotPolicyId;\n        this.attrBurstingEnabled = rosDisk.attrBurstingEnabled;\n        this.attrCategory = rosDisk.attrCategory;\n        this.attrCreateTime = rosDisk.attrCreateTime;\n        this.attrDeleteAutoSnapshot = rosDisk.attrDeleteAutoSnapshot;\n        this.attrDeleteWithInstance = rosDisk.attrDeleteWithInstance;\n        this.attrDescription = rosDisk.attrDescription;\n        this.attrDetachedTime = rosDisk.attrDetachedTime;\n        this.attrDevice = rosDisk.attrDevice;\n        this.attrDiskId = rosDisk.attrDiskId;\n        this.attrDiskName = rosDisk.attrDiskName;\n        this.attrEnableAutoSnapshot = rosDisk.attrEnableAutoSnapshot;\n        this.attrEnableAutomatedSnapshotPolicy = rosDisk.attrEnableAutomatedSnapshotPolicy;\n        this.attrEncrypted = rosDisk.attrEncrypted;\n        this.attrExpiredTime = rosDisk.attrExpiredTime;\n        this.attrImageId = rosDisk.attrImageId;\n        this.attrInstanceId = rosDisk.attrInstanceId;\n        this.attrIops = rosDisk.attrIops;\n        this.attrIopsRead = rosDisk.attrIopsRead;\n        this.attrIopsWrite = rosDisk.attrIopsWrite;\n        this.attrKmsKeyId = rosDisk.attrKmsKeyId;\n        this.attrMountInstanceNum = rosDisk.attrMountInstanceNum;\n        this.attrMountInstances = rosDisk.attrMountInstances;\n        this.attrMultiAttach = rosDisk.attrMultiAttach;\n        this.attrOperationLocks = rosDisk.attrOperationLocks;\n        this.attrPaymentType = rosDisk.attrPaymentType;\n        this.attrPerformanceLevel = rosDisk.attrPerformanceLevel;\n        this.attrPortable = rosDisk.attrPortable;\n        this.attrProductCode = rosDisk.attrProductCode;\n        this.attrProvisionedIops = rosDisk.attrProvisionedIops;\n        this.attrResourceGroupId = rosDisk.attrResourceGroupId;\n        this.attrSize = rosDisk.attrSize;\n        this.attrSnapshotId = rosDisk.attrSnapshotId;\n        this.attrStorageClusterId = rosDisk.attrStorageClusterId;\n        this.attrStorageSetId = rosDisk.attrStorageSetId;\n        this.attrStorageSetPartitionNumber = rosDisk.attrStorageSetPartitionNumber;\n        this.attrTags = rosDisk.attrTags;\n        this.attrZoneId = rosDisk.attrZoneId;\n    }\n}\n"]}