@alicloud/ros-cdk-ebs 1.5.0 → 1.7.0

package/lib/datasource/ebs.generated.js

@@ -1,8 +1,272 @@
 "use strict";
 // Generated from the AliCloud ROS Resource Specification
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RosDiskReplicaPairs = exports.RosDiskReplicaGroups = void 0;
+exports.RosDiskReplicaPairs = exports.RosDiskReplicaPair = exports.RosDiskReplicaGroups = exports.RosDiskReplicaGroup = exports.RosDedicatedBlockStorageClusters = exports.RosDedicatedBlockStorageCluster = void 0;
 const ros = require("@alicloud/ros-cdk-core");
+/**
+ * Determine whether the given properties match those of a `RosDedicatedBlockStorageClusterProps`
+ *
+ * @param properties - the TypeScript properties of a `RosDedicatedBlockStorageClusterProps`
+ *
+ * @returns the result of the validation.
+ */
+function RosDedicatedBlockStorageClusterPropsValidator(properties) {
+    if (!ros.canInspect(properties)) {
+        return ros.VALIDATION_SUCCESS;
+    }
+    const errors = new ros.ValidationResults();
+    errors.collect(ros.propertyValidator('dedicatedBlockStorageClusterId', ros.requiredValidator)(properties.dedicatedBlockStorageClusterId));
+    errors.collect(ros.propertyValidator('dedicatedBlockStorageClusterId', ros.validateString)(properties.dedicatedBlockStorageClusterId));
+    if (properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {
+        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({
+            data: properties.refreshOptions,
+            allowedValues: ["Always", "Never"],
+        }));
+    }
+    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));
+    return errors.wrap('supplied properties not correct for "RosDedicatedBlockStorageClusterProps"');
+}
+/**
+ * Renders the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DedicatedBlockStorageCluster` resource
+ *
+ * @param properties - the TypeScript properties of a `RosDedicatedBlockStorageClusterProps`
+ *
+ * @returns the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DedicatedBlockStorageCluster` resource.
+ */
+// @ts-ignore TS6133
+function rosDedicatedBlockStorageClusterPropsToRosTemplate(properties, enableResourcePropertyConstraint) {
+    if (!ros.canInspect(properties)) {
+        return properties;
+    }
+    if (enableResourcePropertyConstraint) {
+        RosDedicatedBlockStorageClusterPropsValidator(properties).assertSuccess();
+    }
+    return {
+        'DedicatedBlockStorageClusterId': ros.stringToRosTemplate(properties.dedicatedBlockStorageClusterId),
+        'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),
+    };
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `DATASOURCE::EBS::DedicatedBlockStorageCluster`.
+ * @Note This class does not contain additional functions, so it is recommended to use the `DedicatedBlockStorageCluster` class instead of this class for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-dedicatedblockstoragecluster
+ */
+class RosDedicatedBlockStorageCluster extends ros.RosResource {
+    /**
+     * @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) {
+        super(scope, id, { type: RosDedicatedBlockStorageCluster.ROS_RESOURCE_TYPE_NAME, properties: props });
+        this.attrAvailableCapacity = this.getAtt('AvailableCapacity');
+        this.attrCategory = this.getAtt('Category');
+        this.attrCreateTime = this.getAtt('CreateTime');
+        this.attrDedicatedBlockStorageClusterId = this.getAtt('DedicatedBlockStorageClusterId');
+        this.attrDedicatedBlockStorageClusterName = this.getAtt('DedicatedBlockStorageClusterName');
+        this.attrDeliveryCapacity = this.getAtt('DeliveryCapacity');
+        this.attrDescription = this.getAtt('Description');
+        this.attrExpiredTime = this.getAtt('ExpiredTime');
+        this.attrPerformanceLevel = this.getAtt('PerformanceLevel');
+        this.attrResourceGroupId = this.getAtt('ResourceGroupId');
+        this.attrSupportedCategory = this.getAtt('SupportedCategory');
+        this.attrTags = this.getAtt('Tags');
+        this.attrTotalCapacity = this.getAtt('TotalCapacity');
+        this.attrType = this.getAtt('Type');
+        this.attrUsedCapacity = this.getAtt('UsedCapacity');
+        this.attrZoneId = this.getAtt('ZoneId');
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
+        this.dedicatedBlockStorageClusterId = props.dedicatedBlockStorageClusterId;
+        this.refreshOptions = props.refreshOptions;
+    }
+    get rosProperties() {
+        return {
+            dedicatedBlockStorageClusterId: this.dedicatedBlockStorageClusterId,
+            refreshOptions: this.refreshOptions,
+        };
+    }
+    renderProperties(props) {
+        return rosDedicatedBlockStorageClusterPropsToRosTemplate(props, this.enableResourcePropertyConstraint);
+    }
+}
+exports.RosDedicatedBlockStorageCluster = RosDedicatedBlockStorageCluster;
+/**
+ * The resource type name for this resource class.
+ */
+RosDedicatedBlockStorageCluster.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::EBS::DedicatedBlockStorageCluster";
+/**
+ * Determine whether the given properties match those of a `RosDedicatedBlockStorageClustersProps`
+ *
+ * @param properties - the TypeScript properties of a `RosDedicatedBlockStorageClustersProps`
+ *
+ * @returns the result of the validation.
+ */
+function RosDedicatedBlockStorageClustersPropsValidator(properties) {
+    if (!ros.canInspect(properties)) {
+        return ros.VALIDATION_SUCCESS;
+    }
+    const errors = new ros.ValidationResults();
+    errors.collect(ros.propertyValidator('resourceGroupId', ros.validateString)(properties.resourceGroupId));
+    errors.collect(ros.propertyValidator('dedicatedBlockStorageClusterId', ros.validateString)(properties.dedicatedBlockStorageClusterId));
+    if (properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {
+        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({
+            data: properties.refreshOptions,
+            allowedValues: ["Always", "Never"],
+        }));
+    }
+    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));
+    return errors.wrap('supplied properties not correct for "RosDedicatedBlockStorageClustersProps"');
+}
+/**
+ * Renders the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DedicatedBlockStorageClusters` resource
+ *
+ * @param properties - the TypeScript properties of a `RosDedicatedBlockStorageClustersProps`
+ *
+ * @returns the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DedicatedBlockStorageClusters` resource.
+ */
+// @ts-ignore TS6133
+function rosDedicatedBlockStorageClustersPropsToRosTemplate(properties, enableResourcePropertyConstraint) {
+    if (!ros.canInspect(properties)) {
+        return properties;
+    }
+    if (enableResourcePropertyConstraint) {
+        RosDedicatedBlockStorageClustersPropsValidator(properties).assertSuccess();
+    }
+    return {
+        'DedicatedBlockStorageClusterId': ros.stringToRosTemplate(properties.dedicatedBlockStorageClusterId),
+        'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),
+        'ResourceGroupId': ros.stringToRosTemplate(properties.resourceGroupId),
+    };
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `DATASOURCE::EBS::DedicatedBlockStorageClusters`.
+ * @Note This class does not contain additional functions, so it is recommended to use the `DedicatedBlockStorageClusters` class instead of this class for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-dedicatedblockstorageclusters
+ */
+class RosDedicatedBlockStorageClusters extends ros.RosResource {
+    /**
+     * @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) {
+        super(scope, id, { type: RosDedicatedBlockStorageClusters.ROS_RESOURCE_TYPE_NAME, properties: props });
+        this.attrDedicatedBlockStorageClusterIds = this.getAtt('DedicatedBlockStorageClusterIds');
+        this.attrDedicatedBlockStorageClusters = this.getAtt('DedicatedBlockStorageClusters');
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
+        this.dedicatedBlockStorageClusterId = props.dedicatedBlockStorageClusterId;
+        this.refreshOptions = props.refreshOptions;
+        this.resourceGroupId = props.resourceGroupId;
+    }
+    get rosProperties() {
+        return {
+            dedicatedBlockStorageClusterId: this.dedicatedBlockStorageClusterId,
+            refreshOptions: this.refreshOptions,
+            resourceGroupId: this.resourceGroupId,
+        };
+    }
+    renderProperties(props) {
+        return rosDedicatedBlockStorageClustersPropsToRosTemplate(props, this.enableResourcePropertyConstraint);
+    }
+}
+exports.RosDedicatedBlockStorageClusters = RosDedicatedBlockStorageClusters;
+/**
+ * The resource type name for this resource class.
+ */
+RosDedicatedBlockStorageClusters.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::EBS::DedicatedBlockStorageClusters";
+/**
+ * Determine whether the given properties match those of a `RosDiskReplicaGroupProps`
+ *
+ * @param properties - the TypeScript properties of a `RosDiskReplicaGroupProps`
+ *
+ * @returns the result of the validation.
+ */
+function RosDiskReplicaGroupPropsValidator(properties) {
+    if (!ros.canInspect(properties)) {
+        return ros.VALIDATION_SUCCESS;
+    }
+    const errors = new ros.ValidationResults();
+    errors.collect(ros.propertyValidator('replicaGroupId', ros.requiredValidator)(properties.replicaGroupId));
+    errors.collect(ros.propertyValidator('replicaGroupId', ros.validateString)(properties.replicaGroupId));
+    if (properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {
+        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({
+            data: properties.refreshOptions,
+            allowedValues: ["Always", "Never"],
+        }));
+    }
+    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));
+    return errors.wrap('supplied properties not correct for "RosDiskReplicaGroupProps"');
+}
+/**
+ * Renders the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaGroup` resource
+ *
+ * @param properties - the TypeScript properties of a `RosDiskReplicaGroupProps`
+ *
+ * @returns the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaGroup` resource.
+ */
+// @ts-ignore TS6133
+function rosDiskReplicaGroupPropsToRosTemplate(properties, enableResourcePropertyConstraint) {
+    if (!ros.canInspect(properties)) {
+        return properties;
+    }
+    if (enableResourcePropertyConstraint) {
+        RosDiskReplicaGroupPropsValidator(properties).assertSuccess();
+    }
+    return {
+        'ReplicaGroupId': ros.stringToRosTemplate(properties.replicaGroupId),
+        'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),
+    };
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `DATASOURCE::EBS::DiskReplicaGroup`.
+ * @Note This class does not contain additional functions, so it is recommended to use the `DiskReplicaGroup` class instead of this class for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicagroup
+ */
+class RosDiskReplicaGroup extends ros.RosResource {
+    /**
+     * @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) {
+        super(scope, id, { type: RosDiskReplicaGroup.ROS_RESOURCE_TYPE_NAME, properties: props });
+        this.attrDescription = this.getAtt('Description');
+        this.attrDestinationRegionId = this.getAtt('DestinationRegionId');
+        this.attrDestinationZoneId = this.getAtt('DestinationZoneId');
+        this.attrDiskReplicaGroupName = this.getAtt('DiskReplicaGroupName');
+        this.attrLastRecoverPoint = this.getAtt('LastRecoverPoint');
+        this.attrPairIds = this.getAtt('PairIds');
+        this.attrPairNumber = this.getAtt('PairNumber');
+        this.attrPrimaryRegion = this.getAtt('PrimaryRegion');
+        this.attrPrimaryZone = this.getAtt('PrimaryZone');
+        this.attrRpo = this.getAtt('RPO');
+        this.attrReplicaGroupId = this.getAtt('ReplicaGroupId');
+        this.attrResourceGroupId = this.getAtt('ResourceGroupId');
+        this.attrSite = this.getAtt('Site');
+        this.attrSourceRegionId = this.getAtt('SourceRegionId');
+        this.attrSourceZoneId = this.getAtt('SourceZoneId');
+        this.attrStandbyRegion = this.getAtt('StandbyRegion');
+        this.attrStandbyZone = this.getAtt('StandbyZone');
+        this.attrTags = this.getAtt('Tags');
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
+        this.replicaGroupId = props.replicaGroupId;
+        this.refreshOptions = props.refreshOptions;
+    }
+    get rosProperties() {
+        return {
+            replicaGroupId: this.replicaGroupId,
+            refreshOptions: this.refreshOptions,
+        };
+    }
+    renderProperties(props) {
+        return rosDiskReplicaGroupPropsToRosTemplate(props, this.enableResourcePropertyConstraint);
+    }
+}
+exports.RosDiskReplicaGroup = RosDiskReplicaGroup;
+/**
+ * The resource type name for this resource class.
+ */
+RosDiskReplicaGroup.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::EBS::DiskReplicaGroup";
 /**
  * Determine whether the given properties match those of a `RosDiskReplicaGroupsProps`
  *
@@ -83,6 +347,95 @@ exports.RosDiskReplicaGroups = RosDiskReplicaGroups;
  * The resource type name for this resource class.
  */
 RosDiskReplicaGroups.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::EBS::DiskReplicaGroups";
+/**
+ * Determine whether the given properties match those of a `RosDiskReplicaPairProps`
+ *
+ * @param properties - the TypeScript properties of a `RosDiskReplicaPairProps`
+ *
+ * @returns the result of the validation.
+ */
+function RosDiskReplicaPairPropsValidator(properties) {
+    if (!ros.canInspect(properties)) {
+        return ros.VALIDATION_SUCCESS;
+    }
+    const errors = new ros.ValidationResults();
+    errors.collect(ros.propertyValidator('replicaPairId', ros.requiredValidator)(properties.replicaPairId));
+    errors.collect(ros.propertyValidator('replicaPairId', ros.validateString)(properties.replicaPairId));
+    if (properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {
+        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({
+            data: properties.refreshOptions,
+            allowedValues: ["Always", "Never"],
+        }));
+    }
+    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));
+    return errors.wrap('supplied properties not correct for "RosDiskReplicaPairProps"');
+}
+/**
+ * Renders the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaPair` resource
+ *
+ * @param properties - the TypeScript properties of a `RosDiskReplicaPairProps`
+ *
+ * @returns the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaPair` resource.
+ */
+// @ts-ignore TS6133
+function rosDiskReplicaPairPropsToRosTemplate(properties, enableResourcePropertyConstraint) {
+    if (!ros.canInspect(properties)) {
+        return properties;
+    }
+    if (enableResourcePropertyConstraint) {
+        RosDiskReplicaPairPropsValidator(properties).assertSuccess();
+    }
+    return {
+        'ReplicaPairId': ros.stringToRosTemplate(properties.replicaPairId),
+        'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),
+    };
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `DATASOURCE::EBS::DiskReplicaPair`.
+ * @Note This class does not contain additional functions, so it is recommended to use the `DiskReplicaPair` class instead of this class for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicapair
+ */
+class RosDiskReplicaPair extends ros.RosResource {
+    /**
+     * @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) {
+        super(scope, id, { type: RosDiskReplicaPair.ROS_RESOURCE_TYPE_NAME, properties: props });
+        this.attrBandwidth = this.getAtt('Bandwidth');
+        this.attrCreateTime = this.getAtt('CreateTime');
+        this.attrDescription = this.getAtt('Description');
+        this.attrDestinationDiskId = this.getAtt('DestinationDiskId');
+        this.attrDestinationRegionId = this.getAtt('DestinationRegionId');
+        this.attrDestinationZoneId = this.getAtt('DestinationZoneId');
+        this.attrDiskId = this.getAtt('DiskId');
+        this.attrDiskReplicaPairName = this.getAtt('DiskReplicaPairName');
+        this.attrPaymentType = this.getAtt('PaymentType');
+        this.attrRpo = this.getAtt('RPO');
+        this.attrReplicaPairId = this.getAtt('ReplicaPairId');
+        this.attrResourceGroupId = this.getAtt('ResourceGroupId');
+        this.attrSourceZoneId = this.getAtt('SourceZoneId');
+        this.attrTags = this.getAtt('Tags');
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
+        this.replicaPairId = props.replicaPairId;
+        this.refreshOptions = props.refreshOptions;
+    }
+    get rosProperties() {
+        return {
+            replicaPairId: this.replicaPairId,
+            refreshOptions: this.refreshOptions,
+        };
+    }
+    renderProperties(props) {
+        return rosDiskReplicaPairPropsToRosTemplate(props, this.enableResourcePropertyConstraint);
+    }
+}
+exports.RosDiskReplicaPair = RosDiskReplicaPair;
+/**
+ * The resource type name for this resource class.
+ */
+RosDiskReplicaPair.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::EBS::DiskReplicaPair";
 /**
  * Determine whether the given properties match those of a `RosDiskReplicaPairsProps`
  *
@@ -159,4 +512,4 @@ exports.RosDiskReplicaPairs = RosDiskReplicaPairs;
  * The resource type name for this resource class.
  */
 RosDiskReplicaPairs.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::EBS::DiskReplicaPairs";
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ebs.generated.js","sourceRoot":"","sources":["ebs.generated.ts"],"names":[],"mappings":"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","sourcesContent":["// Generated from the AliCloud ROS Resource Specification\n\nimport * as ros from '@alicloud/ros-cdk-core';\n\n/**\n * Properties for defining a `RosDiskReplicaGroups`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicagroups\n */\nexport interface RosDiskReplicaGroupsProps {\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    readonly refreshOptions?: string | ros.IResolvable;\n\n    /**\n     * @Property resourceGroupId: The ID of resource group.\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n\n    /**\n     * @Property site: Site information sources for replication pairs and consistent replication groups. Possible values:\n     * - production: production site.\n     * - backup: disaster recovery site.\n     */\n    readonly site?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosDiskReplicaGroupsProps`\n *\n * @param properties - the TypeScript properties of a `RosDiskReplicaGroupsProps`\n *\n * @returns the result of the validation.\n */\nfunction RosDiskReplicaGroupsPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('site', ros.validateString)(properties.site));\n    errors.collect(ros.propertyValidator('resourceGroupId', ros.validateString)(properties.resourceGroupId));\n    if(properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {\n        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({\n          data: properties.refreshOptions,\n          allowedValues: [\"Always\",\"Never\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));\n    return errors.wrap('supplied properties not correct for \"RosDiskReplicaGroupsProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaGroups` resource\n *\n * @param properties - the TypeScript properties of a `RosDiskReplicaGroupsProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaGroups` resource.\n */\n// @ts-ignore TS6133\nfunction rosDiskReplicaGroupsPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosDiskReplicaGroupsPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n      'ResourceGroupId': ros.stringToRosTemplate(properties.resourceGroupId),\n      'Site': ros.stringToRosTemplate(properties.site),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::EBS::DiskReplicaGroups`, which is used to query the information about replication pair-consistent groups.\n * @Note This class does not contain additional functions, so it is recommended to use the `DiskReplicaGroups` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicagroups\n */\nexport class RosDiskReplicaGroups extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::EBS::DiskReplicaGroups\";\n\n    /**\n     * @Attribute DiskReplicaGroups: The list of disk replica groups.\n     */\n    public readonly attrDiskReplicaGroups: ros.IResolvable;\n\n    /**\n     * @Attribute ReplicaGroupIds: The list of replica group IDs.\n     */\n    public readonly attrReplicaGroupIds: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    public refreshOptions: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property resourceGroupId: The ID of resource group.\n     */\n    public resourceGroupId: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property site: Site information sources for replication pairs and consistent replication groups. Possible values:\n     * - production: production site.\n     * - backup: disaster recovery site.\n     */\n    public site: string | ros.IResolvable | undefined;\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: RosDiskReplicaGroupsProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosDiskReplicaGroups.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrDiskReplicaGroups = this.getAtt('DiskReplicaGroups');\n        this.attrReplicaGroupIds = this.getAtt('ReplicaGroupIds');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n        this.resourceGroupId = props.resourceGroupId;\n        this.site = props.site;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n            resourceGroupId: this.resourceGroupId,\n            site: this.site,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosDiskReplicaGroupsPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosDiskReplicaPairs`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicapairs\n */\nexport interface RosDiskReplicaPairsProps {\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    readonly refreshOptions?: string | ros.IResolvable;\n\n    /**\n     * @Property resourceGroupId: The ID of the resource group.\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosDiskReplicaPairsProps`\n *\n * @param properties - the TypeScript properties of a `RosDiskReplicaPairsProps`\n *\n * @returns the result of the validation.\n */\nfunction RosDiskReplicaPairsPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('resourceGroupId', ros.validateString)(properties.resourceGroupId));\n    if(properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {\n        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({\n          data: properties.refreshOptions,\n          allowedValues: [\"Always\",\"Never\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));\n    return errors.wrap('supplied properties not correct for \"RosDiskReplicaPairsProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaPairs` resource\n *\n * @param properties - the TypeScript properties of a `RosDiskReplicaPairsProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaPairs` resource.\n */\n// @ts-ignore TS6133\nfunction rosDiskReplicaPairsPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosDiskReplicaPairsPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n      'ResourceGroupId': ros.stringToRosTemplate(properties.resourceGroupId),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::EBS::DiskReplicaPairs`, which is used to query the information about replication pairs.\n * @Note This class does not contain additional functions, so it is recommended to use the `DiskReplicaPairs` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicapairs\n */\nexport class RosDiskReplicaPairs extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::EBS::DiskReplicaPairs\";\n\n    /**\n     * @Attribute DiskReplicaPairs: The list of disk replica pairs.\n     */\n    public readonly attrDiskReplicaPairs: ros.IResolvable;\n\n    /**\n     * @Attribute ReplicaPairIds: The list of replica pair IDs.\n     */\n    public readonly attrReplicaPairIds: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    public refreshOptions: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property resourceGroupId: The ID of the resource group.\n     */\n    public resourceGroupId: string | ros.IResolvable | undefined;\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: RosDiskReplicaPairsProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosDiskReplicaPairs.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrDiskReplicaPairs = this.getAtt('DiskReplicaPairs');\n        this.attrReplicaPairIds = this.getAtt('ReplicaPairIds');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n        this.resourceGroupId = props.resourceGroupId;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n            resourceGroupId: this.resourceGroupId,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosDiskReplicaPairsPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ebs.generated.js","sourceRoot":"","sources":["ebs.generated.ts"],"names":[],"mappings":"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","sourcesContent":["// Generated from the AliCloud ROS Resource Specification\n\nimport * as ros from '@alicloud/ros-cdk-core';\n\n/**\n * Properties for defining a `RosDedicatedBlockStorageCluster`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-dedicatedblockstoragecluster\n */\nexport interface RosDedicatedBlockStorageClusterProps {\n\n    /**\n     * @Property dedicatedBlockStorageClusterId: The ID of the dedicated block storage cluster.\n     */\n    readonly dedicatedBlockStorageClusterId: string | ros.IResolvable;\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    readonly refreshOptions?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosDedicatedBlockStorageClusterProps`\n *\n * @param properties - the TypeScript properties of a `RosDedicatedBlockStorageClusterProps`\n *\n * @returns the result of the validation.\n */\nfunction RosDedicatedBlockStorageClusterPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('dedicatedBlockStorageClusterId', ros.requiredValidator)(properties.dedicatedBlockStorageClusterId));\n    errors.collect(ros.propertyValidator('dedicatedBlockStorageClusterId', ros.validateString)(properties.dedicatedBlockStorageClusterId));\n    if(properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {\n        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({\n          data: properties.refreshOptions,\n          allowedValues: [\"Always\",\"Never\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));\n    return errors.wrap('supplied properties not correct for \"RosDedicatedBlockStorageClusterProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DedicatedBlockStorageCluster` resource\n *\n * @param properties - the TypeScript properties of a `RosDedicatedBlockStorageClusterProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DedicatedBlockStorageCluster` resource.\n */\n// @ts-ignore TS6133\nfunction rosDedicatedBlockStorageClusterPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosDedicatedBlockStorageClusterPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'DedicatedBlockStorageClusterId': ros.stringToRosTemplate(properties.dedicatedBlockStorageClusterId),\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::EBS::DedicatedBlockStorageCluster`.\n * @Note This class does not contain additional functions, so it is recommended to use the `DedicatedBlockStorageCluster` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-dedicatedblockstoragecluster\n */\nexport class RosDedicatedBlockStorageCluster extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::EBS::DedicatedBlockStorageCluster\";\n\n    /**\n     * @Attribute AvailableCapacity: The available capacity of the dedicated block storage cluster. Unit: GiB.\n     */\n    public readonly attrAvailableCapacity: ros.IResolvable;\n\n    /**\n     * @Attribute Category: The category of disks that can be created in the dedicated block storage cluster.\n     */\n    public readonly attrCategory: ros.IResolvable;\n\n    /**\n     * @Attribute CreateTime: The time when the dedicated block storage cluster was created. The value is a UNIX timestamp. Unit: seconds.\n     */\n    public readonly attrCreateTime: ros.IResolvable;\n\n    /**\n     * @Attribute DedicatedBlockStorageClusterId: The ID of the dedicated block storage cluster.\n     */\n    public readonly attrDedicatedBlockStorageClusterId: ros.IResolvable;\n\n    /**\n     * @Attribute DedicatedBlockStorageClusterName: The name of the dedicated block storage cluster.\n     */\n    public readonly attrDedicatedBlockStorageClusterName: ros.IResolvable;\n\n    /**\n     * @Attribute DeliveryCapacity: The capacity to be delivered for the dedicated block storage cluster. Unit: GiB.\n     */\n    public readonly attrDeliveryCapacity: ros.IResolvable;\n\n    /**\n     * @Attribute Description: The description of the dedicated block storage cluster.\n     */\n    public readonly attrDescription: ros.IResolvable;\n\n    /**\n     * @Attribute ExpiredTime: The expiration time of the dedicated block storage cluster, in the Unix timestamp format, in seconds.\n     */\n    public readonly attrExpiredTime: ros.IResolvable;\n\n    /**\n     * @Attribute PerformanceLevel: The performance level of disks.\n     */\n    public readonly attrPerformanceLevel: ros.IResolvable;\n\n    /**\n     * @Attribute ResourceGroupId: The ID of the resource group.\n     */\n    public readonly attrResourceGroupId: ros.IResolvable;\n\n    /**\n     * @Attribute SupportedCategory: This parameter is not supported.\n     */\n    public readonly attrSupportedCategory: ros.IResolvable;\n\n    /**\n     * @Attribute Tags: The tags of the dedicated block storage cluster.\n     */\n    public readonly attrTags: ros.IResolvable;\n\n    /**\n     * @Attribute TotalCapacity: The total capacity of the dedicated block storage cluster. Unit: GiB.\n     */\n    public readonly attrTotalCapacity: ros.IResolvable;\n\n    /**\n     * @Attribute Type: The dedicated block storage cluster performance type.\n     */\n    public readonly attrType: ros.IResolvable;\n\n    /**\n     * @Attribute UsedCapacity: The used (created disk) capacity of the current cluster, in GB.\n     */\n    public readonly attrUsedCapacity: ros.IResolvable;\n\n    /**\n     * @Attribute ZoneId: The zone ID of the dedicated block storage cluster.\n     */\n    public readonly attrZoneId: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property dedicatedBlockStorageClusterId: The ID of the dedicated block storage cluster.\n     */\n    public dedicatedBlockStorageClusterId: string | ros.IResolvable;\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    public refreshOptions: string | ros.IResolvable | undefined;\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: RosDedicatedBlockStorageClusterProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosDedicatedBlockStorageCluster.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrAvailableCapacity = this.getAtt('AvailableCapacity');\n        this.attrCategory = this.getAtt('Category');\n        this.attrCreateTime = this.getAtt('CreateTime');\n        this.attrDedicatedBlockStorageClusterId = this.getAtt('DedicatedBlockStorageClusterId');\n        this.attrDedicatedBlockStorageClusterName = this.getAtt('DedicatedBlockStorageClusterName');\n        this.attrDeliveryCapacity = this.getAtt('DeliveryCapacity');\n        this.attrDescription = this.getAtt('Description');\n        this.attrExpiredTime = this.getAtt('ExpiredTime');\n        this.attrPerformanceLevel = this.getAtt('PerformanceLevel');\n        this.attrResourceGroupId = this.getAtt('ResourceGroupId');\n        this.attrSupportedCategory = this.getAtt('SupportedCategory');\n        this.attrTags = this.getAtt('Tags');\n        this.attrTotalCapacity = this.getAtt('TotalCapacity');\n        this.attrType = this.getAtt('Type');\n        this.attrUsedCapacity = this.getAtt('UsedCapacity');\n        this.attrZoneId = this.getAtt('ZoneId');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.dedicatedBlockStorageClusterId = props.dedicatedBlockStorageClusterId;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            dedicatedBlockStorageClusterId: this.dedicatedBlockStorageClusterId,\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosDedicatedBlockStorageClusterPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosDedicatedBlockStorageClusters`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-dedicatedblockstorageclusters\n */\nexport interface RosDedicatedBlockStorageClustersProps {\n\n    /**\n     * @Property dedicatedBlockStorageClusterId: The ID of the dedicated block storage cluster.\n     */\n    readonly dedicatedBlockStorageClusterId?: string | ros.IResolvable;\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    readonly refreshOptions?: string | ros.IResolvable;\n\n    /**\n     * @Property resourceGroupId: The ID of the resource group.\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosDedicatedBlockStorageClustersProps`\n *\n * @param properties - the TypeScript properties of a `RosDedicatedBlockStorageClustersProps`\n *\n * @returns the result of the validation.\n */\nfunction RosDedicatedBlockStorageClustersPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('resourceGroupId', ros.validateString)(properties.resourceGroupId));\n    errors.collect(ros.propertyValidator('dedicatedBlockStorageClusterId', ros.validateString)(properties.dedicatedBlockStorageClusterId));\n    if(properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {\n        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({\n          data: properties.refreshOptions,\n          allowedValues: [\"Always\",\"Never\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));\n    return errors.wrap('supplied properties not correct for \"RosDedicatedBlockStorageClustersProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DedicatedBlockStorageClusters` resource\n *\n * @param properties - the TypeScript properties of a `RosDedicatedBlockStorageClustersProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DedicatedBlockStorageClusters` resource.\n */\n// @ts-ignore TS6133\nfunction rosDedicatedBlockStorageClustersPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosDedicatedBlockStorageClustersPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'DedicatedBlockStorageClusterId': ros.stringToRosTemplate(properties.dedicatedBlockStorageClusterId),\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n      'ResourceGroupId': ros.stringToRosTemplate(properties.resourceGroupId),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::EBS::DedicatedBlockStorageClusters`.\n * @Note This class does not contain additional functions, so it is recommended to use the `DedicatedBlockStorageClusters` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-dedicatedblockstorageclusters\n */\nexport class RosDedicatedBlockStorageClusters extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::EBS::DedicatedBlockStorageClusters\";\n\n    /**\n     * @Attribute DedicatedBlockStorageClusterIds: The list of dedicated block storage cluster IDs.\n     */\n    public readonly attrDedicatedBlockStorageClusterIds: ros.IResolvable;\n\n    /**\n     * @Attribute DedicatedBlockStorageClusters: The list of dedicated block storage clusters.\n     */\n    public readonly attrDedicatedBlockStorageClusters: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property dedicatedBlockStorageClusterId: The ID of the dedicated block storage cluster.\n     */\n    public dedicatedBlockStorageClusterId: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    public refreshOptions: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property resourceGroupId: The ID of the resource group.\n     */\n    public resourceGroupId: string | ros.IResolvable | undefined;\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: RosDedicatedBlockStorageClustersProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosDedicatedBlockStorageClusters.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrDedicatedBlockStorageClusterIds = this.getAtt('DedicatedBlockStorageClusterIds');\n        this.attrDedicatedBlockStorageClusters = this.getAtt('DedicatedBlockStorageClusters');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.dedicatedBlockStorageClusterId = props.dedicatedBlockStorageClusterId;\n        this.refreshOptions = props.refreshOptions;\n        this.resourceGroupId = props.resourceGroupId;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            dedicatedBlockStorageClusterId: this.dedicatedBlockStorageClusterId,\n            refreshOptions: this.refreshOptions,\n            resourceGroupId: this.resourceGroupId,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosDedicatedBlockStorageClustersPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosDiskReplicaGroup`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicagroup\n */\nexport interface RosDiskReplicaGroupProps {\n\n    /**\n     * @Property replicaGroupId: The ID of the consistent replication group.\n     */\n    readonly replicaGroupId: string | ros.IResolvable;\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    readonly refreshOptions?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosDiskReplicaGroupProps`\n *\n * @param properties - the TypeScript properties of a `RosDiskReplicaGroupProps`\n *\n * @returns the result of the validation.\n */\nfunction RosDiskReplicaGroupPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('replicaGroupId', ros.requiredValidator)(properties.replicaGroupId));\n    errors.collect(ros.propertyValidator('replicaGroupId', ros.validateString)(properties.replicaGroupId));\n    if(properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {\n        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({\n          data: properties.refreshOptions,\n          allowedValues: [\"Always\",\"Never\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));\n    return errors.wrap('supplied properties not correct for \"RosDiskReplicaGroupProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaGroup` resource\n *\n * @param properties - the TypeScript properties of a `RosDiskReplicaGroupProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaGroup` resource.\n */\n// @ts-ignore TS6133\nfunction rosDiskReplicaGroupPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosDiskReplicaGroupPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'ReplicaGroupId': ros.stringToRosTemplate(properties.replicaGroupId),\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::EBS::DiskReplicaGroup`.\n * @Note This class does not contain additional functions, so it is recommended to use the `DiskReplicaGroup` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicagroup\n */\nexport class RosDiskReplicaGroup extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::EBS::DiskReplicaGroup\";\n\n    /**\n     * @Attribute Description: The description of the consistent replication group.\n     */\n    public readonly attrDescription: ros.IResolvable;\n\n    /**\n     * @Attribute DestinationRegionId: The ID of the region to which the disaster recovery site belongs.\n     */\n    public readonly attrDestinationRegionId: ros.IResolvable;\n\n    /**\n     * @Attribute DestinationZoneId: The ID of the zone to which the disaster recovery site belongs.\n     */\n    public readonly attrDestinationZoneId: ros.IResolvable;\n\n    /**\n     * @Attribute DiskReplicaGroupName: The name of the consistent replication group.\n     */\n    public readonly attrDiskReplicaGroupName: ros.IResolvable;\n\n    /**\n     * @Attribute LastRecoverPoint: The time when the last asynchronous replication operation of the consistent replication group completed. This parameter provides the return value as a timestamp. Unit: seconds.\n     */\n    public readonly attrLastRecoverPoint: ros.IResolvable;\n\n    /**\n     * @Attribute PairIds: List of replication pair IDs contained in a consistent replication group.\n     */\n    public readonly attrPairIds: ros.IResolvable;\n\n    /**\n     * @Attribute PairNumber: The number of replication pairs contained in a consistent replication group.\n     */\n    public readonly attrPairNumber: ros.IResolvable;\n\n    /**\n     * @Attribute PrimaryRegion: The initial source region of the replication group.\n     */\n    public readonly attrPrimaryRegion: ros.IResolvable;\n\n    /**\n     * @Attribute PrimaryZone: The initial source available area of the replication group.\n     */\n    public readonly attrPrimaryZone: ros.IResolvable;\n\n    /**\n     * @Attribute RPO: The RPO value set by the consistency group in seconds. Currently only 900 seconds are supported.\n     */\n    public readonly attrRpo: ros.IResolvable;\n\n    /**\n     * @Attribute ReplicaGroupId: The ID of the consistent replication group.\n     */\n    public readonly attrReplicaGroupId: ros.IResolvable;\n\n    /**\n     * @Attribute ResourceGroupId: The ID of resource group.\n     */\n    public readonly attrResourceGroupId: ros.IResolvable;\n\n    /**\n     * @Attribute Site: Site information sources for replication pairs and consistent replication groups.\n     */\n    public readonly attrSite: ros.IResolvable;\n\n    /**\n     * @Attribute SourceRegionId: The ID of the region to which the production site belongs.\n     */\n    public readonly attrSourceRegionId: ros.IResolvable;\n\n    /**\n     * @Attribute SourceZoneId: The ID of the zone to which the production site belongs.\n     */\n    public readonly attrSourceZoneId: ros.IResolvable;\n\n    /**\n     * @Attribute StandbyRegion: The initial destination region of the replication group.\n     */\n    public readonly attrStandbyRegion: ros.IResolvable;\n\n    /**\n     * @Attribute StandbyZone: The initial destination zone of the replication group.\n     */\n    public readonly attrStandbyZone: ros.IResolvable;\n\n    /**\n     * @Attribute Tags: The tags of the replication pair-consistent group.\n     */\n    public readonly attrTags: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property replicaGroupId: The ID of the consistent replication group.\n     */\n    public replicaGroupId: string | ros.IResolvable;\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    public refreshOptions: string | ros.IResolvable | undefined;\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: RosDiskReplicaGroupProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosDiskReplicaGroup.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrDescription = this.getAtt('Description');\n        this.attrDestinationRegionId = this.getAtt('DestinationRegionId');\n        this.attrDestinationZoneId = this.getAtt('DestinationZoneId');\n        this.attrDiskReplicaGroupName = this.getAtt('DiskReplicaGroupName');\n        this.attrLastRecoverPoint = this.getAtt('LastRecoverPoint');\n        this.attrPairIds = this.getAtt('PairIds');\n        this.attrPairNumber = this.getAtt('PairNumber');\n        this.attrPrimaryRegion = this.getAtt('PrimaryRegion');\n        this.attrPrimaryZone = this.getAtt('PrimaryZone');\n        this.attrRpo = this.getAtt('RPO');\n        this.attrReplicaGroupId = this.getAtt('ReplicaGroupId');\n        this.attrResourceGroupId = this.getAtt('ResourceGroupId');\n        this.attrSite = this.getAtt('Site');\n        this.attrSourceRegionId = this.getAtt('SourceRegionId');\n        this.attrSourceZoneId = this.getAtt('SourceZoneId');\n        this.attrStandbyRegion = this.getAtt('StandbyRegion');\n        this.attrStandbyZone = this.getAtt('StandbyZone');\n        this.attrTags = this.getAtt('Tags');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.replicaGroupId = props.replicaGroupId;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            replicaGroupId: this.replicaGroupId,\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosDiskReplicaGroupPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosDiskReplicaGroups`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicagroups\n */\nexport interface RosDiskReplicaGroupsProps {\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    readonly refreshOptions?: string | ros.IResolvable;\n\n    /**\n     * @Property resourceGroupId: The ID of resource group.\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n\n    /**\n     * @Property site: Site information sources for replication pairs and consistent replication groups. Possible values:\n     * - production: production site.\n     * - backup: disaster recovery site.\n     */\n    readonly site?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosDiskReplicaGroupsProps`\n *\n * @param properties - the TypeScript properties of a `RosDiskReplicaGroupsProps`\n *\n * @returns the result of the validation.\n */\nfunction RosDiskReplicaGroupsPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('site', ros.validateString)(properties.site));\n    errors.collect(ros.propertyValidator('resourceGroupId', ros.validateString)(properties.resourceGroupId));\n    if(properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {\n        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({\n          data: properties.refreshOptions,\n          allowedValues: [\"Always\",\"Never\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));\n    return errors.wrap('supplied properties not correct for \"RosDiskReplicaGroupsProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaGroups` resource\n *\n * @param properties - the TypeScript properties of a `RosDiskReplicaGroupsProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaGroups` resource.\n */\n// @ts-ignore TS6133\nfunction rosDiskReplicaGroupsPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosDiskReplicaGroupsPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n      'ResourceGroupId': ros.stringToRosTemplate(properties.resourceGroupId),\n      'Site': ros.stringToRosTemplate(properties.site),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::EBS::DiskReplicaGroups`, which is used to query the information about replication pair-consistent groups.\n * @Note This class does not contain additional functions, so it is recommended to use the `DiskReplicaGroups` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicagroups\n */\nexport class RosDiskReplicaGroups extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::EBS::DiskReplicaGroups\";\n\n    /**\n     * @Attribute DiskReplicaGroups: The list of disk replica groups.\n     */\n    public readonly attrDiskReplicaGroups: ros.IResolvable;\n\n    /**\n     * @Attribute ReplicaGroupIds: The list of replica group IDs.\n     */\n    public readonly attrReplicaGroupIds: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    public refreshOptions: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property resourceGroupId: The ID of resource group.\n     */\n    public resourceGroupId: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property site: Site information sources for replication pairs and consistent replication groups. Possible values:\n     * - production: production site.\n     * - backup: disaster recovery site.\n     */\n    public site: string | ros.IResolvable | undefined;\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: RosDiskReplicaGroupsProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosDiskReplicaGroups.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrDiskReplicaGroups = this.getAtt('DiskReplicaGroups');\n        this.attrReplicaGroupIds = this.getAtt('ReplicaGroupIds');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n        this.resourceGroupId = props.resourceGroupId;\n        this.site = props.site;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n            resourceGroupId: this.resourceGroupId,\n            site: this.site,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosDiskReplicaGroupsPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosDiskReplicaPair`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicapair\n */\nexport interface RosDiskReplicaPairProps {\n\n    /**\n     * @Property replicaPairId: The ID of the replication pair.\n     */\n    readonly replicaPairId: string | ros.IResolvable;\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    readonly refreshOptions?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosDiskReplicaPairProps`\n *\n * @param properties - the TypeScript properties of a `RosDiskReplicaPairProps`\n *\n * @returns the result of the validation.\n */\nfunction RosDiskReplicaPairPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('replicaPairId', ros.requiredValidator)(properties.replicaPairId));\n    errors.collect(ros.propertyValidator('replicaPairId', ros.validateString)(properties.replicaPairId));\n    if(properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {\n        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({\n          data: properties.refreshOptions,\n          allowedValues: [\"Always\",\"Never\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));\n    return errors.wrap('supplied properties not correct for \"RosDiskReplicaPairProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaPair` resource\n *\n * @param properties - the TypeScript properties of a `RosDiskReplicaPairProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaPair` resource.\n */\n// @ts-ignore TS6133\nfunction rosDiskReplicaPairPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosDiskReplicaPairPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'ReplicaPairId': ros.stringToRosTemplate(properties.replicaPairId),\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::EBS::DiskReplicaPair`.\n * @Note This class does not contain additional functions, so it is recommended to use the `DiskReplicaPair` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicapair\n */\nexport class RosDiskReplicaPair extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::EBS::DiskReplicaPair\";\n\n    /**\n     * @Attribute Bandwidth: The bandwidth for asynchronous data replication between cloud disks. The unit is Kbps.\n     */\n    public readonly attrBandwidth: ros.IResolvable;\n\n    /**\n     * @Attribute CreateTime: The time when the replication pair was created. The value of this parameter is a timestamp. Unit: seconds.\n     */\n    public readonly attrCreateTime: ros.IResolvable;\n\n    /**\n     * @Attribute Description: The description of the replication pair.\n     */\n    public readonly attrDescription: ros.IResolvable;\n\n    /**\n     * @Attribute DestinationDiskId: The ID of the secondary disk.\n     */\n    public readonly attrDestinationDiskId: ros.IResolvable;\n\n    /**\n     * @Attribute DestinationRegionId: The ID of the region to which the disaster recovery site belongs.\n     */\n    public readonly attrDestinationRegionId: ros.IResolvable;\n\n    /**\n     * @Attribute DestinationZoneId: The ID of the zone to which the disaster recovery site belongs.\n     */\n    public readonly attrDestinationZoneId: ros.IResolvable;\n\n    /**\n     * @Attribute DiskId: The ID of the primary disk.\n     */\n    public readonly attrDiskId: ros.IResolvable;\n\n    /**\n     * @Attribute DiskReplicaPairName: The name of the asynchronous replication relationship.\n     */\n    public readonly attrDiskReplicaPairName: ros.IResolvable;\n\n    /**\n     * @Attribute PaymentType: The payment type of the replication pair.\n     */\n    public readonly attrPaymentType: ros.IResolvable;\n\n    /**\n     * @Attribute RPO: The recovery point objective (RPO) of the replication pair. Unit: seconds.\n     */\n    public readonly attrRpo: ros.IResolvable;\n\n    /**\n     * @Attribute ReplicaPairId: The ID of the replication pair.\n     */\n    public readonly attrReplicaPairId: ros.IResolvable;\n\n    /**\n     * @Attribute ResourceGroupId: The ID of the resource group.\n     */\n    public readonly attrResourceGroupId: ros.IResolvable;\n\n    /**\n     * @Attribute SourceZoneId: The zone ID of the primary disk.\n     */\n    public readonly attrSourceZoneId: ros.IResolvable;\n\n    /**\n     * @Attribute Tags: The tags of the replication pair.\n     */\n    public readonly attrTags: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property replicaPairId: The ID of the replication pair.\n     */\n    public replicaPairId: string | ros.IResolvable;\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    public refreshOptions: string | ros.IResolvable | undefined;\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: RosDiskReplicaPairProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosDiskReplicaPair.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrBandwidth = this.getAtt('Bandwidth');\n        this.attrCreateTime = this.getAtt('CreateTime');\n        this.attrDescription = this.getAtt('Description');\n        this.attrDestinationDiskId = this.getAtt('DestinationDiskId');\n        this.attrDestinationRegionId = this.getAtt('DestinationRegionId');\n        this.attrDestinationZoneId = this.getAtt('DestinationZoneId');\n        this.attrDiskId = this.getAtt('DiskId');\n        this.attrDiskReplicaPairName = this.getAtt('DiskReplicaPairName');\n        this.attrPaymentType = this.getAtt('PaymentType');\n        this.attrRpo = this.getAtt('RPO');\n        this.attrReplicaPairId = this.getAtt('ReplicaPairId');\n        this.attrResourceGroupId = this.getAtt('ResourceGroupId');\n        this.attrSourceZoneId = this.getAtt('SourceZoneId');\n        this.attrTags = this.getAtt('Tags');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.replicaPairId = props.replicaPairId;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            replicaPairId: this.replicaPairId,\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosDiskReplicaPairPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosDiskReplicaPairs`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicapairs\n */\nexport interface RosDiskReplicaPairsProps {\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    readonly refreshOptions?: string | ros.IResolvable;\n\n    /**\n     * @Property resourceGroupId: The ID of the resource group.\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosDiskReplicaPairsProps`\n *\n * @param properties - the TypeScript properties of a `RosDiskReplicaPairsProps`\n *\n * @returns the result of the validation.\n */\nfunction RosDiskReplicaPairsPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('resourceGroupId', ros.validateString)(properties.resourceGroupId));\n    if(properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {\n        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({\n          data: properties.refreshOptions,\n          allowedValues: [\"Always\",\"Never\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));\n    return errors.wrap('supplied properties not correct for \"RosDiskReplicaPairsProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaPairs` resource\n *\n * @param properties - the TypeScript properties of a `RosDiskReplicaPairsProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::EBS::DiskReplicaPairs` resource.\n */\n// @ts-ignore TS6133\nfunction rosDiskReplicaPairsPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosDiskReplicaPairsPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n      'ResourceGroupId': ros.stringToRosTemplate(properties.resourceGroupId),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::EBS::DiskReplicaPairs`, which is used to query the information about replication pairs.\n * @Note This class does not contain additional functions, so it is recommended to use the `DiskReplicaPairs` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-ebs-diskreplicapairs\n */\nexport class RosDiskReplicaPairs extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::EBS::DiskReplicaPairs\";\n\n    /**\n     * @Attribute DiskReplicaPairs: The list of disk replica pairs.\n     */\n    public readonly attrDiskReplicaPairs: ros.IResolvable;\n\n    /**\n     * @Attribute ReplicaPairIds: The list of replica pair IDs.\n     */\n    public readonly attrReplicaPairIds: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    public refreshOptions: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property resourceGroupId: The ID of the resource group.\n     */\n    public resourceGroupId: string | ros.IResolvable | undefined;\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: RosDiskReplicaPairsProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosDiskReplicaPairs.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrDiskReplicaPairs = this.getAtt('DiskReplicaPairs');\n        this.attrReplicaPairIds = this.getAtt('ReplicaPairIds');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n        this.resourceGroupId = props.resourceGroupId;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n            resourceGroupId: this.resourceGroupId,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosDiskReplicaPairsPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n"]}

package/lib/datasource/index.d.ts

@@ -1,3 +1,7 @@
+export * from './dedicatedblockstoragecluster';
+export * from './dedicatedblockstorageclusters';
+export * from './diskreplicagroup';
 export * from './diskreplicagroups';
+export * from './diskreplicapair';
 export * from './diskreplicapairs';
 export * from './ebs.generated';

package/lib/datasource/index.js

@@ -10,8 +10,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dedicatedblockstoragecluster"), exports);
+__exportStar(require("./dedicatedblockstorageclusters"), exports);
+__exportStar(require("./diskreplicagroup"), exports);
 __exportStar(require("./diskreplicagroups"), exports);
+__exportStar(require("./diskreplicapair"), exports);
 __exportStar(require("./diskreplicapairs"), exports);
 // DATASOURCE::EBS Resources:
 __exportStar(require("./ebs.generated"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSxzREFBb0M7QUFDcEMscURBQW1DO0FBRW5DLDZCQUE2QjtBQUM3QixrREFBZ0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Rpc2tyZXBsaWNhZ3JvdXBzJztcbmV4cG9ydCAqIGZyb20gJy4vZGlza3JlcGxpY2FwYWlycyc7XG5cbi8vIERBVEFTT1VSQ0U6OkVCUyBSZXNvdXJjZXM6XG5leHBvcnQgKiBmcm9tICcuL2Vicy5nZW5lcmF0ZWQnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSxpRUFBK0M7QUFDL0Msa0VBQWdEO0FBQ2hELHFEQUFtQztBQUNuQyxzREFBb0M7QUFDcEMsb0RBQWtDO0FBQ2xDLHFEQUFtQztBQUVuQyw2QkFBNkI7QUFDN0Isa0RBQWdDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kZWRpY2F0ZWRibG9ja3N0b3JhZ2VjbHVzdGVyJztcbmV4cG9ydCAqIGZyb20gJy4vZGVkaWNhdGVkYmxvY2tzdG9yYWdlY2x1c3RlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXNrcmVwbGljYWdyb3VwJztcbmV4cG9ydCAqIGZyb20gJy4vZGlza3JlcGxpY2Fncm91cHMnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXNrcmVwbGljYXBhaXInO1xuZXhwb3J0ICogZnJvbSAnLi9kaXNrcmVwbGljYXBhaXJzJztcblxuLy8gREFUQVNPVVJDRTo6RUJTIFJlc291cmNlczpcbmV4cG9ydCAqIGZyb20gJy4vZWJzLmdlbmVyYXRlZCc7XG4iXX0=