@alicloud/ros-cdk-kms 1.3.0 → 1.4.0

package/lib/datasource/index.d.ts

@@ -4,5 +4,6 @@ export * from './networkrule';
 export * from './networkrules';
 export * from './policies';
 export * from './policy';
+export * from './secret';
 export * from './secrets';
 export * from './kms.generated';

package/lib/datasource/index.js

@@ -16,7 +16,8 @@ __exportStar(require("./networkrule"), exports);
 __exportStar(require("./networkrules"), exports);
 __exportStar(require("./policies"), exports);
 __exportStar(require("./policy"), exports);
+__exportStar(require("./secret"), exports);
 __exportStar(require("./secrets"), exports);
 // DATASOURCE::KMS Resources:
 __exportStar(require("./kms.generated"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw2Q0FBMkI7QUFDM0IsOENBQTRCO0FBQzVCLGdEQUE4QjtBQUM5QixpREFBK0I7QUFDL0IsNkNBQTJCO0FBQzNCLDJDQUF5QjtBQUN6Qiw0Q0FBMEI7QUFFMUIsNkJBQTZCO0FBQzdCLGtEQUFnQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW5zdGFuY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnN0YW5jZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9uZXR3b3JrcnVsZSc7XG5leHBvcnQgKiBmcm9tICcuL25ldHdvcmtydWxlcyc7XG5leHBvcnQgKiBmcm9tICcuL3BvbGljaWVzJztcbmV4cG9ydCAqIGZyb20gJy4vcG9saWN5JztcbmV4cG9ydCAqIGZyb20gJy4vc2VjcmV0cyc7XG5cbi8vIERBVEFTT1VSQ0U6OktNUyBSZXNvdXJjZXM6XG5leHBvcnQgKiBmcm9tICcuL2ttcy5nZW5lcmF0ZWQnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw2Q0FBMkI7QUFDM0IsOENBQTRCO0FBQzVCLGdEQUE4QjtBQUM5QixpREFBK0I7QUFDL0IsNkNBQTJCO0FBQzNCLDJDQUF5QjtBQUN6QiwyQ0FBeUI7QUFDekIsNENBQTBCO0FBRTFCLDZCQUE2QjtBQUM3QixrREFBZ0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2luc3RhbmNlJztcbmV4cG9ydCAqIGZyb20gJy4vaW5zdGFuY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbmV0d29ya3J1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9uZXR3b3JrcnVsZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9wb2xpY2llcyc7XG5leHBvcnQgKiBmcm9tICcuL3BvbGljeSc7XG5leHBvcnQgKiBmcm9tICcuL3NlY3JldCc7XG5leHBvcnQgKiBmcm9tICcuL3NlY3JldHMnO1xuXG4vLyBEQVRBU09VUkNFOjpLTVMgUmVzb3VyY2VzOlxuZXhwb3J0ICogZnJvbSAnLi9rbXMuZ2VuZXJhdGVkJztcbiJdfQ==

package/lib/datasource/kms.generated.d.ts

@@ -395,6 +395,116 @@ export declare class RosPolicy extends ros.RosResource {
         [key: string]: any;
     };
 }
+/**
+ * Properties for defining a `RosSecret`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secret
+ */
+export interface RosSecretProps {
+    /**
+     * @Property secretName: The name of the secret.
+     */
+    readonly secretName: string | ros.IResolvable;
+    /**
+     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:
+     * - Never: Never refresh the datasource resource when the stack is updated.
+     * - Always: Always refresh the datasource resource when the stack is updated.
+     * Default is Never.
+     */
+    readonly refreshOptions?: string | ros.IResolvable;
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Secret`.
+ * @Note This class does not contain additional functions, so it is recommended to use the `Secret` class instead of this class for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secret
+ */
+export declare class RosSecret extends ros.RosResource {
+    /**
+     * The resource type name for this resource class.
+     */
+    static readonly ROS_RESOURCE_TYPE_NAME = "DATASOURCE::KMS::Secret";
+    /**
+     * @Attribute Arn: The Alibaba Cloud Resource Name (ARN) of the secret.
+     */
+    readonly attrArn: ros.IResolvable;
+    /**
+     * @Attribute AutomaticRotation: Indicates whether automatic rotation is enabled.
+     */
+    readonly attrAutomaticRotation: ros.IResolvable;
+    /**
+     * @Attribute CreateTime: The time when the secret was created.
+     */
+    readonly attrCreateTime: ros.IResolvable;
+    /**
+     * @Attribute DKMSInstanceId: The ID of the dedicated KMS instance.
+     */
+    readonly attrDkmsInstanceId: ros.IResolvable;
+    /**
+     * @Attribute Description: The description of the secret.
+     */
+    readonly attrDescription: ros.IResolvable;
+    /**
+     * @Attribute EncryptionKeyId: The ID of the customer master key (CMK) that is used to encrypt the secret value.
+     */
+    readonly attrEncryptionKeyId: ros.IResolvable;
+    /**
+     * @Attribute ExtendedConfig: The extended configuration of the secret.
+     */
+    readonly attrExtendedConfig: ros.IResolvable;
+    /**
+     * @Attribute LastRotationDate: The time when the last rotation was performed.
+     */
+    readonly attrLastRotationDate: ros.IResolvable;
+    /**
+     * @Attribute NextRotationDate: The time when the next rotation will be performed.
+     */
+    readonly attrNextRotationDate: ros.IResolvable;
+    /**
+     * @Attribute PlannedDeleteTime: The time when the secret is scheduled to be deleted.
+     */
+    readonly attrPlannedDeleteTime: ros.IResolvable;
+    /**
+     * @Attribute RotationInterval: The interval for automatic rotation. The value is in the integer[unit] format. integer indicates the length of time. unit: indicates the time unit. The value of unit is fixed as s. For example, if the value is 604800s, automatic rotation is performed at a 7-day interval.The value is in the integer[unit] format. integer indicates the length of time. unit: indicates the time unit. The value of unit is fixed as s. For example, if the value is 604800s, automatic rotation is performed at a 7-day interval.
+     */
+    readonly attrRotationInterval: ros.IResolvable;
+    /**
+     * @Attribute SecretName: The name of the secret.
+     */
+    readonly attrSecretName: ros.IResolvable;
+    /**
+     * @Attribute SecretType: The type of the secret.
+     */
+    readonly attrSecretType: ros.IResolvable;
+    /**
+     * @Attribute UpdateTime: The time when the secret was updated.
+     */
+    readonly attrUpdateTime: ros.IResolvable;
+    enableResourcePropertyConstraint: boolean;
+    /**
+     * @Property secretName: The name of the secret.
+     */
+    secretName: string | ros.IResolvable;
+    /**
+     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:
+     * - Never: Never refresh the datasource resource when the stack is updated.
+     * - Always: Always refresh the datasource resource when the stack is updated.
+     * Default is Never.
+     */
+    refreshOptions: string | ros.IResolvable | undefined;
+    /**
+     * @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: RosSecretProps, enableResourcePropertyConstraint: boolean);
+    protected get rosProperties(): {
+        [key: string]: any;
+    };
+    protected renderProperties(props: {
+        [key: string]: any;
+    }): {
+        [key: string]: any;
+    };
+}
 /**
  * Properties for defining a `RosSecrets`.
  * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secrets

package/lib/datasource/kms.generated.js

@@ -1,7 +1,7 @@
 "use strict";
 // Generated from the AliCloud ROS Resource Specification
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RosSecrets = exports.RosPolicy = exports.RosPolicies = exports.RosNetworkRules = exports.RosNetworkRule = exports.RosInstances = exports.RosInstance = void 0;
+exports.RosSecrets = exports.RosSecret = exports.RosPolicy = exports.RosPolicies = exports.RosNetworkRules = exports.RosNetworkRule = exports.RosInstances = exports.RosInstance = void 0;
 const ros = require("@alicloud/ros-cdk-core");
 /**
  * Determine whether the given properties match those of a `RosInstanceProps`
@@ -462,6 +462,95 @@ exports.RosPolicy = RosPolicy;
  * The resource type name for this resource class.
  */
 RosPolicy.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::KMS::Policy";
+/**
+ * Determine whether the given properties match those of a `RosSecretProps`
+ *
+ * @param properties - the TypeScript properties of a `RosSecretProps`
+ *
+ * @returns the result of the validation.
+ */
+function RosSecretPropsValidator(properties) {
+    if (!ros.canInspect(properties)) {
+        return ros.VALIDATION_SUCCESS;
+    }
+    const errors = new ros.ValidationResults();
+    errors.collect(ros.propertyValidator('secretName', ros.requiredValidator)(properties.secretName));
+    errors.collect(ros.propertyValidator('secretName', ros.validateString)(properties.secretName));
+    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 "RosSecretProps"');
+}
+/**
+ * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Secret` resource
+ *
+ * @param properties - the TypeScript properties of a `RosSecretProps`
+ *
+ * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Secret` resource.
+ */
+// @ts-ignore TS6133
+function rosSecretPropsToRosTemplate(properties, enableResourcePropertyConstraint) {
+    if (!ros.canInspect(properties)) {
+        return properties;
+    }
+    if (enableResourcePropertyConstraint) {
+        RosSecretPropsValidator(properties).assertSuccess();
+    }
+    return {
+        'SecretName': ros.stringToRosTemplate(properties.secretName),
+        'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),
+    };
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Secret`.
+ * @Note This class does not contain additional functions, so it is recommended to use the `Secret` class instead of this class for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secret
+ */
+class RosSecret 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: RosSecret.ROS_RESOURCE_TYPE_NAME, properties: props });
+        this.attrArn = this.getAtt('Arn');
+        this.attrAutomaticRotation = this.getAtt('AutomaticRotation');
+        this.attrCreateTime = this.getAtt('CreateTime');
+        this.attrDkmsInstanceId = this.getAtt('DKMSInstanceId');
+        this.attrDescription = this.getAtt('Description');
+        this.attrEncryptionKeyId = this.getAtt('EncryptionKeyId');
+        this.attrExtendedConfig = this.getAtt('ExtendedConfig');
+        this.attrLastRotationDate = this.getAtt('LastRotationDate');
+        this.attrNextRotationDate = this.getAtt('NextRotationDate');
+        this.attrPlannedDeleteTime = this.getAtt('PlannedDeleteTime');
+        this.attrRotationInterval = this.getAtt('RotationInterval');
+        this.attrSecretName = this.getAtt('SecretName');
+        this.attrSecretType = this.getAtt('SecretType');
+        this.attrUpdateTime = this.getAtt('UpdateTime');
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
+        this.secretName = props.secretName;
+        this.refreshOptions = props.refreshOptions;
+    }
+    get rosProperties() {
+        return {
+            secretName: this.secretName,
+            refreshOptions: this.refreshOptions,
+        };
+    }
+    renderProperties(props) {
+        return rosSecretPropsToRosTemplate(props, this.enableResourcePropertyConstraint);
+    }
+}
+exports.RosSecret = RosSecret;
+/**
+ * The resource type name for this resource class.
+ */
+RosSecret.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::KMS::Secret";
 /**
  * Determine whether the given properties match those of a `RosSecretsProps`
  *
@@ -534,4 +623,4 @@ exports.RosSecrets = RosSecrets;
  * The resource type name for this resource class.
  */
 RosSecrets.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::KMS::Secrets";
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kms.generated.js","sourceRoot":"","sources":["kms.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 `RosInstance`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-instance\n */\nexport interface RosInstanceProps {\n\n    /**\n     * @Property instanceId: The ID of the KMS instance.\n     */\n    readonly instanceId: 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 `RosInstanceProps`\n *\n * @param properties - the TypeScript properties of a `RosInstanceProps`\n *\n * @returns the result of the validation.\n */\nfunction RosInstancePropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('instanceId', ros.requiredValidator)(properties.instanceId));\n    errors.collect(ros.propertyValidator('instanceId', ros.validateString)(properties.instanceId));\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 \"RosInstanceProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Instance` resource\n *\n * @param properties - the TypeScript properties of a `RosInstanceProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Instance` resource.\n */\n// @ts-ignore TS6133\nfunction rosInstancePropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosInstancePropsValidator(properties).assertSuccess();\n    }\n    return {\n      'InstanceId': ros.stringToRosTemplate(properties.instanceId),\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Instance`.\n * @Note This class does not contain additional functions, so it is recommended to use the `Instance` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-instance\n */\nexport class RosInstance extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::Instance\";\n\n    /**\n     * @Attribute CreateTime: The time when the KMS instance is created.\n     */\n    public readonly attrCreateTime: ros.IResolvable;\n\n    /**\n     * @Attribute InstanceId: The ID of the KMS instance.\n     */\n    public readonly attrInstanceId: ros.IResolvable;\n\n    /**\n     * @Attribute InstanceName: The name of the KMS instance.\n     */\n    public readonly attrInstanceName: ros.IResolvable;\n\n    /**\n     * @Attribute KeyNum: The number of keys that can be created for the KMS instance.\n     */\n    public readonly attrKeyNum: ros.IResolvable;\n\n    /**\n     * @Attribute SecretNum: The number of secrets that can be created for the KMS instance.\n     */\n    public readonly attrSecretNum: ros.IResolvable;\n\n    /**\n     * @Attribute Spec: The computation performance level of the KMS instance.\n     */\n    public readonly attrSpec: ros.IResolvable;\n\n    /**\n     * @Attribute VpcId: The virtual private cloud (VPC) with which the KMS instance is associated..\n     */\n    public readonly attrVpcId: ros.IResolvable;\n\n    /**\n     * @Attribute VpcNum: The number of managed accesses. The maximum number of VPCs that can access this KMS instance.\n     */\n    public readonly attrVpcNum: ros.IResolvable;\n\n    /**\n     * @Attribute VswitchIds: The VSwitch in the VPC.\n     */\n    public readonly attrVswitchIds: ros.IResolvable;\n\n    /**\n     * @Attribute ZoneIds: The zone with which the KMS instance is associated.\n     */\n    public readonly attrZoneIds: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property instanceId: The ID of the KMS instance.\n     */\n    public instanceId: 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: RosInstanceProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosInstance.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrCreateTime = this.getAtt('CreateTime');\n        this.attrInstanceId = this.getAtt('InstanceId');\n        this.attrInstanceName = this.getAtt('InstanceName');\n        this.attrKeyNum = this.getAtt('KeyNum');\n        this.attrSecretNum = this.getAtt('SecretNum');\n        this.attrSpec = this.getAtt('Spec');\n        this.attrVpcId = this.getAtt('VpcId');\n        this.attrVpcNum = this.getAtt('VpcNum');\n        this.attrVswitchIds = this.getAtt('VswitchIds');\n        this.attrZoneIds = this.getAtt('ZoneIds');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.instanceId = props.instanceId;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            instanceId: this.instanceId,\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosInstancePropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosInstances`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-instances\n */\nexport interface RosInstancesProps {\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 `RosInstancesProps`\n *\n * @param properties - the TypeScript properties of a `RosInstancesProps`\n *\n * @returns the result of the validation.\n */\nfunction RosInstancesPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\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 \"RosInstancesProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Instances` resource\n *\n * @param properties - the TypeScript properties of a `RosInstancesProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Instances` resource.\n */\n// @ts-ignore TS6133\nfunction rosInstancesPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosInstancesPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Instances`.\n * @Note This class does not contain additional functions, so it is recommended to use the `Instances` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-instances\n */\nexport class RosInstances extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::Instances\";\n\n    /**\n     * @Attribute InstanceIds: The list of instance IDs.\n     */\n    public readonly attrInstanceIds: ros.IResolvable;\n\n    /**\n     * @Attribute Instances: The list of instances.\n     */\n    public readonly attrInstances: 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     * @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: RosInstancesProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosInstances.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrInstanceIds = this.getAtt('InstanceIds');\n        this.attrInstances = this.getAtt('Instances');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosInstancesPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosNetworkRule`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-networkrule\n */\nexport interface RosNetworkRuleProps {\n\n    /**\n     * @Property networkRuleName: The name of the access control rule.\n     */\n    readonly networkRuleName: 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 `RosNetworkRuleProps`\n *\n * @param properties - the TypeScript properties of a `RosNetworkRuleProps`\n *\n * @returns the result of the validation.\n */\nfunction RosNetworkRulePropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('networkRuleName', ros.requiredValidator)(properties.networkRuleName));\n    errors.collect(ros.propertyValidator('networkRuleName', ros.validateString)(properties.networkRuleName));\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 \"RosNetworkRuleProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::NetworkRule` resource\n *\n * @param properties - the TypeScript properties of a `RosNetworkRuleProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::NetworkRule` resource.\n */\n// @ts-ignore TS6133\nfunction rosNetworkRulePropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosNetworkRulePropsValidator(properties).assertSuccess();\n    }\n    return {\n      'NetworkRuleName': ros.stringToRosTemplate(properties.networkRuleName),\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::NetworkRule`.\n * @Note This class does not contain additional functions, so it is recommended to use the `NetworkRule` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-networkrule\n */\nexport class RosNetworkRule extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::NetworkRule\";\n\n    /**\n     * @Attribute Description: The access control rule description.\n     */\n    public readonly attrDescription: ros.IResolvable;\n\n    /**\n     * @Attribute SourcePrivateIp: The private IP address or private CIDR block.\n     */\n    public readonly attrSourcePrivateIp: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property networkRuleName: The name of the access control rule.\n     */\n    public networkRuleName: 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: RosNetworkRuleProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosNetworkRule.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrDescription = this.getAtt('Description');\n        this.attrSourcePrivateIp = this.getAtt('SourcePrivateIp');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.networkRuleName = props.networkRuleName;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            networkRuleName: this.networkRuleName,\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosNetworkRulePropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosNetworkRules`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-networkrules\n */\nexport interface RosNetworkRulesProps {\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 `RosNetworkRulesProps`\n *\n * @param properties - the TypeScript properties of a `RosNetworkRulesProps`\n *\n * @returns the result of the validation.\n */\nfunction RosNetworkRulesPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\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 \"RosNetworkRulesProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::NetworkRules` resource\n *\n * @param properties - the TypeScript properties of a `RosNetworkRulesProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::NetworkRules` resource.\n */\n// @ts-ignore TS6133\nfunction rosNetworkRulesPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosNetworkRulesPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::NetworkRules`.\n * @Note This class does not contain additional functions, so it is recommended to use the `NetworkRules` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-networkrules\n */\nexport class RosNetworkRules extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::NetworkRules\";\n\n    /**\n     * @Attribute NetworkRuleNames: The list of network rule names.\n     */\n    public readonly attrNetworkRuleNames: ros.IResolvable;\n\n    /**\n     * @Attribute NetworkRules: The list of network rules.\n     */\n    public readonly attrNetworkRules: 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     * @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: RosNetworkRulesProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosNetworkRules.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrNetworkRuleNames = this.getAtt('NetworkRuleNames');\n        this.attrNetworkRules = this.getAtt('NetworkRules');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosNetworkRulesPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosPolicies`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-policies\n */\nexport interface RosPoliciesProps {\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 `RosPoliciesProps`\n *\n * @param properties - the TypeScript properties of a `RosPoliciesProps`\n *\n * @returns the result of the validation.\n */\nfunction RosPoliciesPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\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 \"RosPoliciesProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Policies` resource\n *\n * @param properties - the TypeScript properties of a `RosPoliciesProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Policies` resource.\n */\n// @ts-ignore TS6133\nfunction rosPoliciesPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosPoliciesPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Policies`.\n * @Note This class does not contain additional functions, so it is recommended to use the `Policies` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-policies\n */\nexport class RosPolicies extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::Policies\";\n\n    /**\n     * @Attribute Policies: The list of policies.\n     */\n    public readonly attrPolicies: ros.IResolvable;\n\n    /**\n     * @Attribute PolicyNames: The list of policy names.\n     */\n    public readonly attrPolicyNames: 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     * @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: RosPoliciesProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosPolicies.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrPolicies = this.getAtt('Policies');\n        this.attrPolicyNames = this.getAtt('PolicyNames');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosPoliciesPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosPolicy`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-policy\n */\nexport interface RosPolicyProps {\n\n    /**\n     * @Property policyName: The name of the permission policy.\n     */\n    readonly policyName: 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 `RosPolicyProps`\n *\n * @param properties - the TypeScript properties of a `RosPolicyProps`\n *\n * @returns the result of the validation.\n */\nfunction RosPolicyPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('policyName', ros.requiredValidator)(properties.policyName));\n    errors.collect(ros.propertyValidator('policyName', ros.validateString)(properties.policyName));\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 \"RosPolicyProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Policy` resource\n *\n * @param properties - the TypeScript properties of a `RosPolicyProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Policy` resource.\n */\n// @ts-ignore TS6133\nfunction rosPolicyPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosPolicyPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'PolicyName': ros.stringToRosTemplate(properties.policyName),\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Policy`.\n * @Note This class does not contain additional functions, so it is recommended to use the `Policy` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-policy\n */\nexport class RosPolicy extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::Policy\";\n\n    /**\n     * @Attribute Description: The policy description.\n     */\n    public readonly attrDescription: ros.IResolvable;\n\n    /**\n     * @Attribute KmsInstanceId: KMS instance accessed by this policy.\n     */\n    public readonly attrKmsInstanceId: ros.IResolvable;\n\n    /**\n     * @Attribute NetworkRules: The network access rule that is associated with the permission policy.\n     */\n    public readonly attrNetworkRules: ros.IResolvable;\n\n    /**\n     * @Attribute Permissions: A list of operations that can be performed.\n     */\n    public readonly attrPermissions: ros.IResolvable;\n\n    /**\n     * @Attribute PolicyName: The name of the permission policy.\n     */\n    public readonly attrPolicyName: ros.IResolvable;\n\n    /**\n     * @Attribute Resources: A list of keys and secrets that are allowed to access.\n     */\n    public readonly attrResources: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property policyName: The name of the permission policy.\n     */\n    public policyName: 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: RosPolicyProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosPolicy.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrDescription = this.getAtt('Description');\n        this.attrKmsInstanceId = this.getAtt('KmsInstanceId');\n        this.attrNetworkRules = this.getAtt('NetworkRules');\n        this.attrPermissions = this.getAtt('Permissions');\n        this.attrPolicyName = this.getAtt('PolicyName');\n        this.attrResources = this.getAtt('Resources');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.policyName = props.policyName;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            policyName: this.policyName,\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosPolicyPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosSecrets`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secrets\n */\nexport interface RosSecretsProps {\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 `RosSecretsProps`\n *\n * @param properties - the TypeScript properties of a `RosSecretsProps`\n *\n * @returns the result of the validation.\n */\nfunction RosSecretsPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\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 \"RosSecretsProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Secrets` resource\n *\n * @param properties - the TypeScript properties of a `RosSecretsProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Secrets` resource.\n */\n// @ts-ignore TS6133\nfunction rosSecretsPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosSecretsPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Secrets`.\n * @Note This class does not contain additional functions, so it is recommended to use the `Secrets` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secrets\n */\nexport class RosSecrets extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::Secrets\";\n\n    /**\n     * @Attribute SecretNames: The list of secret names.\n     */\n    public readonly attrSecretNames: ros.IResolvable;\n\n    /**\n     * @Attribute Secrets: The list of secrets.\n     */\n    public readonly attrSecrets: 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     * @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: RosSecretsProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosSecrets.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrSecretNames = this.getAtt('SecretNames');\n        this.attrSecrets = this.getAtt('Secrets');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosSecretsPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kms.generated.js","sourceRoot":"","sources":["kms.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 `RosInstance`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-instance\n */\nexport interface RosInstanceProps {\n\n    /**\n     * @Property instanceId: The ID of the KMS instance.\n     */\n    readonly instanceId: 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 `RosInstanceProps`\n *\n * @param properties - the TypeScript properties of a `RosInstanceProps`\n *\n * @returns the result of the validation.\n */\nfunction RosInstancePropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('instanceId', ros.requiredValidator)(properties.instanceId));\n    errors.collect(ros.propertyValidator('instanceId', ros.validateString)(properties.instanceId));\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 \"RosInstanceProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Instance` resource\n *\n * @param properties - the TypeScript properties of a `RosInstanceProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Instance` resource.\n */\n// @ts-ignore TS6133\nfunction rosInstancePropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosInstancePropsValidator(properties).assertSuccess();\n    }\n    return {\n      'InstanceId': ros.stringToRosTemplate(properties.instanceId),\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Instance`.\n * @Note This class does not contain additional functions, so it is recommended to use the `Instance` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-instance\n */\nexport class RosInstance extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::Instance\";\n\n    /**\n     * @Attribute CreateTime: The time when the KMS instance is created.\n     */\n    public readonly attrCreateTime: ros.IResolvable;\n\n    /**\n     * @Attribute InstanceId: The ID of the KMS instance.\n     */\n    public readonly attrInstanceId: ros.IResolvable;\n\n    /**\n     * @Attribute InstanceName: The name of the KMS instance.\n     */\n    public readonly attrInstanceName: ros.IResolvable;\n\n    /**\n     * @Attribute KeyNum: The number of keys that can be created for the KMS instance.\n     */\n    public readonly attrKeyNum: ros.IResolvable;\n\n    /**\n     * @Attribute SecretNum: The number of secrets that can be created for the KMS instance.\n     */\n    public readonly attrSecretNum: ros.IResolvable;\n\n    /**\n     * @Attribute Spec: The computation performance level of the KMS instance.\n     */\n    public readonly attrSpec: ros.IResolvable;\n\n    /**\n     * @Attribute VpcId: The virtual private cloud (VPC) with which the KMS instance is associated..\n     */\n    public readonly attrVpcId: ros.IResolvable;\n\n    /**\n     * @Attribute VpcNum: The number of managed accesses. The maximum number of VPCs that can access this KMS instance.\n     */\n    public readonly attrVpcNum: ros.IResolvable;\n\n    /**\n     * @Attribute VswitchIds: The VSwitch in the VPC.\n     */\n    public readonly attrVswitchIds: ros.IResolvable;\n\n    /**\n     * @Attribute ZoneIds: The zone with which the KMS instance is associated.\n     */\n    public readonly attrZoneIds: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property instanceId: The ID of the KMS instance.\n     */\n    public instanceId: 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: RosInstanceProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosInstance.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrCreateTime = this.getAtt('CreateTime');\n        this.attrInstanceId = this.getAtt('InstanceId');\n        this.attrInstanceName = this.getAtt('InstanceName');\n        this.attrKeyNum = this.getAtt('KeyNum');\n        this.attrSecretNum = this.getAtt('SecretNum');\n        this.attrSpec = this.getAtt('Spec');\n        this.attrVpcId = this.getAtt('VpcId');\n        this.attrVpcNum = this.getAtt('VpcNum');\n        this.attrVswitchIds = this.getAtt('VswitchIds');\n        this.attrZoneIds = this.getAtt('ZoneIds');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.instanceId = props.instanceId;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            instanceId: this.instanceId,\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosInstancePropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosInstances`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-instances\n */\nexport interface RosInstancesProps {\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 `RosInstancesProps`\n *\n * @param properties - the TypeScript properties of a `RosInstancesProps`\n *\n * @returns the result of the validation.\n */\nfunction RosInstancesPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\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 \"RosInstancesProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Instances` resource\n *\n * @param properties - the TypeScript properties of a `RosInstancesProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Instances` resource.\n */\n// @ts-ignore TS6133\nfunction rosInstancesPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosInstancesPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Instances`.\n * @Note This class does not contain additional functions, so it is recommended to use the `Instances` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-instances\n */\nexport class RosInstances extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::Instances\";\n\n    /**\n     * @Attribute InstanceIds: The list of instance IDs.\n     */\n    public readonly attrInstanceIds: ros.IResolvable;\n\n    /**\n     * @Attribute Instances: The list of instances.\n     */\n    public readonly attrInstances: 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     * @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: RosInstancesProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosInstances.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrInstanceIds = this.getAtt('InstanceIds');\n        this.attrInstances = this.getAtt('Instances');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosInstancesPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosNetworkRule`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-networkrule\n */\nexport interface RosNetworkRuleProps {\n\n    /**\n     * @Property networkRuleName: The name of the access control rule.\n     */\n    readonly networkRuleName: 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 `RosNetworkRuleProps`\n *\n * @param properties - the TypeScript properties of a `RosNetworkRuleProps`\n *\n * @returns the result of the validation.\n */\nfunction RosNetworkRulePropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('networkRuleName', ros.requiredValidator)(properties.networkRuleName));\n    errors.collect(ros.propertyValidator('networkRuleName', ros.validateString)(properties.networkRuleName));\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 \"RosNetworkRuleProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::NetworkRule` resource\n *\n * @param properties - the TypeScript properties of a `RosNetworkRuleProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::NetworkRule` resource.\n */\n// @ts-ignore TS6133\nfunction rosNetworkRulePropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosNetworkRulePropsValidator(properties).assertSuccess();\n    }\n    return {\n      'NetworkRuleName': ros.stringToRosTemplate(properties.networkRuleName),\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::NetworkRule`.\n * @Note This class does not contain additional functions, so it is recommended to use the `NetworkRule` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-networkrule\n */\nexport class RosNetworkRule extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::NetworkRule\";\n\n    /**\n     * @Attribute Description: The access control rule description.\n     */\n    public readonly attrDescription: ros.IResolvable;\n\n    /**\n     * @Attribute SourcePrivateIp: The private IP address or private CIDR block.\n     */\n    public readonly attrSourcePrivateIp: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property networkRuleName: The name of the access control rule.\n     */\n    public networkRuleName: 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: RosNetworkRuleProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosNetworkRule.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrDescription = this.getAtt('Description');\n        this.attrSourcePrivateIp = this.getAtt('SourcePrivateIp');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.networkRuleName = props.networkRuleName;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            networkRuleName: this.networkRuleName,\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosNetworkRulePropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosNetworkRules`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-networkrules\n */\nexport interface RosNetworkRulesProps {\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 `RosNetworkRulesProps`\n *\n * @param properties - the TypeScript properties of a `RosNetworkRulesProps`\n *\n * @returns the result of the validation.\n */\nfunction RosNetworkRulesPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\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 \"RosNetworkRulesProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::NetworkRules` resource\n *\n * @param properties - the TypeScript properties of a `RosNetworkRulesProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::NetworkRules` resource.\n */\n// @ts-ignore TS6133\nfunction rosNetworkRulesPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosNetworkRulesPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::NetworkRules`.\n * @Note This class does not contain additional functions, so it is recommended to use the `NetworkRules` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-networkrules\n */\nexport class RosNetworkRules extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::NetworkRules\";\n\n    /**\n     * @Attribute NetworkRuleNames: The list of network rule names.\n     */\n    public readonly attrNetworkRuleNames: ros.IResolvable;\n\n    /**\n     * @Attribute NetworkRules: The list of network rules.\n     */\n    public readonly attrNetworkRules: 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     * @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: RosNetworkRulesProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosNetworkRules.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrNetworkRuleNames = this.getAtt('NetworkRuleNames');\n        this.attrNetworkRules = this.getAtt('NetworkRules');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosNetworkRulesPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosPolicies`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-policies\n */\nexport interface RosPoliciesProps {\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 `RosPoliciesProps`\n *\n * @param properties - the TypeScript properties of a `RosPoliciesProps`\n *\n * @returns the result of the validation.\n */\nfunction RosPoliciesPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\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 \"RosPoliciesProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Policies` resource\n *\n * @param properties - the TypeScript properties of a `RosPoliciesProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Policies` resource.\n */\n// @ts-ignore TS6133\nfunction rosPoliciesPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosPoliciesPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Policies`.\n * @Note This class does not contain additional functions, so it is recommended to use the `Policies` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-policies\n */\nexport class RosPolicies extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::Policies\";\n\n    /**\n     * @Attribute Policies: The list of policies.\n     */\n    public readonly attrPolicies: ros.IResolvable;\n\n    /**\n     * @Attribute PolicyNames: The list of policy names.\n     */\n    public readonly attrPolicyNames: 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     * @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: RosPoliciesProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosPolicies.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrPolicies = this.getAtt('Policies');\n        this.attrPolicyNames = this.getAtt('PolicyNames');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosPoliciesPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosPolicy`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-policy\n */\nexport interface RosPolicyProps {\n\n    /**\n     * @Property policyName: The name of the permission policy.\n     */\n    readonly policyName: 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 `RosPolicyProps`\n *\n * @param properties - the TypeScript properties of a `RosPolicyProps`\n *\n * @returns the result of the validation.\n */\nfunction RosPolicyPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('policyName', ros.requiredValidator)(properties.policyName));\n    errors.collect(ros.propertyValidator('policyName', ros.validateString)(properties.policyName));\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 \"RosPolicyProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Policy` resource\n *\n * @param properties - the TypeScript properties of a `RosPolicyProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Policy` resource.\n */\n// @ts-ignore TS6133\nfunction rosPolicyPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosPolicyPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'PolicyName': ros.stringToRosTemplate(properties.policyName),\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Policy`.\n * @Note This class does not contain additional functions, so it is recommended to use the `Policy` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-policy\n */\nexport class RosPolicy extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::Policy\";\n\n    /**\n     * @Attribute Description: The policy description.\n     */\n    public readonly attrDescription: ros.IResolvable;\n\n    /**\n     * @Attribute KmsInstanceId: KMS instance accessed by this policy.\n     */\n    public readonly attrKmsInstanceId: ros.IResolvable;\n\n    /**\n     * @Attribute NetworkRules: The network access rule that is associated with the permission policy.\n     */\n    public readonly attrNetworkRules: ros.IResolvable;\n\n    /**\n     * @Attribute Permissions: A list of operations that can be performed.\n     */\n    public readonly attrPermissions: ros.IResolvable;\n\n    /**\n     * @Attribute PolicyName: The name of the permission policy.\n     */\n    public readonly attrPolicyName: ros.IResolvable;\n\n    /**\n     * @Attribute Resources: A list of keys and secrets that are allowed to access.\n     */\n    public readonly attrResources: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property policyName: The name of the permission policy.\n     */\n    public policyName: 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: RosPolicyProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosPolicy.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrDescription = this.getAtt('Description');\n        this.attrKmsInstanceId = this.getAtt('KmsInstanceId');\n        this.attrNetworkRules = this.getAtt('NetworkRules');\n        this.attrPermissions = this.getAtt('Permissions');\n        this.attrPolicyName = this.getAtt('PolicyName');\n        this.attrResources = this.getAtt('Resources');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.policyName = props.policyName;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            policyName: this.policyName,\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosPolicyPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosSecret`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secret\n */\nexport interface RosSecretProps {\n\n    /**\n     * @Property secretName: The name of the secret.\n     */\n    readonly secretName: 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 `RosSecretProps`\n *\n * @param properties - the TypeScript properties of a `RosSecretProps`\n *\n * @returns the result of the validation.\n */\nfunction RosSecretPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('secretName', ros.requiredValidator)(properties.secretName));\n    errors.collect(ros.propertyValidator('secretName', ros.validateString)(properties.secretName));\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 \"RosSecretProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Secret` resource\n *\n * @param properties - the TypeScript properties of a `RosSecretProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Secret` resource.\n */\n// @ts-ignore TS6133\nfunction rosSecretPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosSecretPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'SecretName': ros.stringToRosTemplate(properties.secretName),\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Secret`.\n * @Note This class does not contain additional functions, so it is recommended to use the `Secret` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secret\n */\nexport class RosSecret extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::Secret\";\n\n    /**\n     * @Attribute Arn: The Alibaba Cloud Resource Name (ARN) of the secret.\n     */\n    public readonly attrArn: ros.IResolvable;\n\n    /**\n     * @Attribute AutomaticRotation: Indicates whether automatic rotation is enabled.\n     */\n    public readonly attrAutomaticRotation: ros.IResolvable;\n\n    /**\n     * @Attribute CreateTime: The time when the secret was created.\n     */\n    public readonly attrCreateTime: ros.IResolvable;\n\n    /**\n     * @Attribute DKMSInstanceId: The ID of the dedicated KMS instance.\n     */\n    public readonly attrDkmsInstanceId: ros.IResolvable;\n\n    /**\n     * @Attribute Description: The description of the secret.\n     */\n    public readonly attrDescription: ros.IResolvable;\n\n    /**\n     * @Attribute EncryptionKeyId: The ID of the customer master key (CMK) that is used to encrypt the secret value.\n     */\n    public readonly attrEncryptionKeyId: ros.IResolvable;\n\n    /**\n     * @Attribute ExtendedConfig: The extended configuration of the secret.\n     */\n    public readonly attrExtendedConfig: ros.IResolvable;\n\n    /**\n     * @Attribute LastRotationDate: The time when the last rotation was performed.\n     */\n    public readonly attrLastRotationDate: ros.IResolvable;\n\n    /**\n     * @Attribute NextRotationDate: The time when the next rotation will be performed.\n     */\n    public readonly attrNextRotationDate: ros.IResolvable;\n\n    /**\n     * @Attribute PlannedDeleteTime: The time when the secret is scheduled to be deleted.\n     */\n    public readonly attrPlannedDeleteTime: ros.IResolvable;\n\n    /**\n     * @Attribute RotationInterval: The interval for automatic rotation. The value is in the integer[unit] format. integer indicates the length of time. unit: indicates the time unit. The value of unit is fixed as s. For example, if the value is 604800s, automatic rotation is performed at a 7-day interval.The value is in the integer[unit] format. integer indicates the length of time. unit: indicates the time unit. The value of unit is fixed as s. For example, if the value is 604800s, automatic rotation is performed at a 7-day interval.\n     */\n    public readonly attrRotationInterval: ros.IResolvable;\n\n    /**\n     * @Attribute SecretName: The name of the secret.\n     */\n    public readonly attrSecretName: ros.IResolvable;\n\n    /**\n     * @Attribute SecretType: The type of the secret.\n     */\n    public readonly attrSecretType: ros.IResolvable;\n\n    /**\n     * @Attribute UpdateTime: The time when the secret was updated.\n     */\n    public readonly attrUpdateTime: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property secretName: The name of the secret.\n     */\n    public secretName: 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: RosSecretProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosSecret.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrArn = this.getAtt('Arn');\n        this.attrAutomaticRotation = this.getAtt('AutomaticRotation');\n        this.attrCreateTime = this.getAtt('CreateTime');\n        this.attrDkmsInstanceId = this.getAtt('DKMSInstanceId');\n        this.attrDescription = this.getAtt('Description');\n        this.attrEncryptionKeyId = this.getAtt('EncryptionKeyId');\n        this.attrExtendedConfig = this.getAtt('ExtendedConfig');\n        this.attrLastRotationDate = this.getAtt('LastRotationDate');\n        this.attrNextRotationDate = this.getAtt('NextRotationDate');\n        this.attrPlannedDeleteTime = this.getAtt('PlannedDeleteTime');\n        this.attrRotationInterval = this.getAtt('RotationInterval');\n        this.attrSecretName = this.getAtt('SecretName');\n        this.attrSecretType = this.getAtt('SecretType');\n        this.attrUpdateTime = this.getAtt('UpdateTime');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.secretName = props.secretName;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            secretName: this.secretName,\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosSecretPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosSecrets`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secrets\n */\nexport interface RosSecretsProps {\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 `RosSecretsProps`\n *\n * @param properties - the TypeScript properties of a `RosSecretsProps`\n *\n * @returns the result of the validation.\n */\nfunction RosSecretsPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\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 \"RosSecretsProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Secrets` resource\n *\n * @param properties - the TypeScript properties of a `RosSecretsProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::KMS::Secrets` resource.\n */\n// @ts-ignore TS6133\nfunction rosSecretsPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosSecretsPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::KMS::Secrets`.\n * @Note This class does not contain additional functions, so it is recommended to use the `Secrets` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secrets\n */\nexport class RosSecrets extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::KMS::Secrets\";\n\n    /**\n     * @Attribute SecretNames: The list of secret names.\n     */\n    public readonly attrSecretNames: ros.IResolvable;\n\n    /**\n     * @Attribute Secrets: The list of secrets.\n     */\n    public readonly attrSecrets: 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     * @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: RosSecretsProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosSecrets.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrSecretNames = this.getAtt('SecretNames');\n        this.attrSecrets = this.getAtt('Secrets');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosSecretsPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n"]}

package/lib/datasource/secret.d.ts

@@ -0,0 +1,93 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosSecret } from './kms.generated';
+export { RosSecret as SecretProperty };
+/**
+ * Properties for defining a `Secret`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secret
+ */
+export interface SecretProps {
+    /**
+     * Property secretName: The name of the secret.
+     */
+    readonly secretName: string | ros.IResolvable;
+    /**
+     * Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:
+     * - Never: Never refresh the datasource resource when the stack is updated.
+     * - Always: Always refresh the datasource resource when the stack is updated.
+     * Default is Never.
+     */
+    readonly refreshOptions?: string | ros.IResolvable;
+}
+/**
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::KMS::Secret`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosSecret`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secret
+ */
+export declare class Secret extends ros.Resource {
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: SecretProps;
+    protected enableResourcePropertyConstraint: boolean;
+    /**
+     * Attribute Arn: The Alibaba Cloud Resource Name (ARN) of the secret.
+     */
+    readonly attrArn: ros.IResolvable;
+    /**
+     * Attribute AutomaticRotation: Indicates whether automatic rotation is enabled.
+     */
+    readonly attrAutomaticRotation: ros.IResolvable;
+    /**
+     * Attribute CreateTime: The time when the secret was created.
+     */
+    readonly attrCreateTime: ros.IResolvable;
+    /**
+     * Attribute DKMSInstanceId: The ID of the dedicated KMS instance.
+     */
+    readonly attrDkmsInstanceId: ros.IResolvable;
+    /**
+     * Attribute Description: The description of the secret.
+     */
+    readonly attrDescription: ros.IResolvable;
+    /**
+     * Attribute EncryptionKeyId: The ID of the customer master key (CMK) that is used to encrypt the secret value.
+     */
+    readonly attrEncryptionKeyId: ros.IResolvable;
+    /**
+     * Attribute ExtendedConfig: The extended configuration of the secret.
+     */
+    readonly attrExtendedConfig: ros.IResolvable;
+    /**
+     * Attribute LastRotationDate: The time when the last rotation was performed.
+     */
+    readonly attrLastRotationDate: ros.IResolvable;
+    /**
+     * Attribute NextRotationDate: The time when the next rotation will be performed.
+     */
+    readonly attrNextRotationDate: ros.IResolvable;
+    /**
+     * Attribute PlannedDeleteTime: The time when the secret is scheduled to be deleted.
+     */
+    readonly attrPlannedDeleteTime: ros.IResolvable;
+    /**
+     * Attribute RotationInterval: The interval for automatic rotation. The value is in the integer[unit] format. integer indicates the length of time. unit: indicates the time unit. The value of unit is fixed as s. For example, if the value is 604800s, automatic rotation is performed at a 7-day interval.The value is in the integer[unit] format. integer indicates the length of time. unit: indicates the time unit. The value of unit is fixed as s. For example, if the value is 604800s, automatic rotation is performed at a 7-day interval.
+     */
+    readonly attrRotationInterval: ros.IResolvable;
+    /**
+     * Attribute SecretName: The name of the secret.
+     */
+    readonly attrSecretName: ros.IResolvable;
+    /**
+     * Attribute SecretType: The type of the secret.
+     */
+    readonly attrSecretType: ros.IResolvable;
+    /**
+     * Attribute UpdateTime: The time when the secret was updated.
+     */
+    readonly attrUpdateTime: 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: SecretProps, enableResourcePropertyConstraint?: boolean);
+}

package/lib/datasource/secret.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Secret = exports.SecretProperty = void 0;
+const ros = require("@alicloud/ros-cdk-core");
+const kms_generated_1 = require("./kms.generated");
+Object.defineProperty(exports, "SecretProperty", { enumerable: true, get: function () { return kms_generated_1.RosSecret; } });
+/**
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::KMS::Secret`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosSecret`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secret
+ */
+class Secret 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 rosSecret = new kms_generated_1.RosSecret(this, id, {
+            secretName: props.secretName,
+            refreshOptions: props.refreshOptions === undefined || props.refreshOptions === null ? 'Never' : props.refreshOptions,
+        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
+        this.resource = rosSecret;
+        this.attrArn = rosSecret.attrArn;
+        this.attrAutomaticRotation = rosSecret.attrAutomaticRotation;
+        this.attrCreateTime = rosSecret.attrCreateTime;
+        this.attrDkmsInstanceId = rosSecret.attrDkmsInstanceId;
+        this.attrDescription = rosSecret.attrDescription;
+        this.attrEncryptionKeyId = rosSecret.attrEncryptionKeyId;
+        this.attrExtendedConfig = rosSecret.attrExtendedConfig;
+        this.attrLastRotationDate = rosSecret.attrLastRotationDate;
+        this.attrNextRotationDate = rosSecret.attrNextRotationDate;
+        this.attrPlannedDeleteTime = rosSecret.attrPlannedDeleteTime;
+        this.attrRotationInterval = rosSecret.attrRotationInterval;
+        this.attrSecretName = rosSecret.attrSecretName;
+        this.attrSecretType = rosSecret.attrSecretType;
+        this.attrUpdateTime = rosSecret.attrUpdateTime;
+    }
+}
+exports.Secret = Secret;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secret.js","sourceRoot":"","sources":["secret.ts"],"names":[],"mappings":";;;AAAA,8CAA8C;AAC9C,mDAA4C;AAEtB,+FAFb,yBAAS,OAEkB;AAsBpC;;;;GAIG;AACH,MAAa,MAAO,SAAQ,GAAG,CAAC,QAAQ;IA4EpC;;;;OAIG;IACH,YAAY,KAAoB,EAAE,EAAU,EAAE,KAAkB,EAAE,mCAA2C,IAAI;QAC7G,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,SAAS,GAAG,IAAI,yBAAS,CAAC,IAAI,EAAE,EAAE,EAAG;YACvC,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,cAAc,EAAE,KAAK,CAAC,cAAc,KAAK,SAAS,IAAI,KAAK,CAAC,cAAc,KAAK,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,cAAc;SACvH,EAAE,gCAAgC,IAAI,IAAI,CAAC,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpF,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;QACjC,IAAI,CAAC,qBAAqB,GAAG,SAAS,CAAC,qBAAqB,CAAC;QAC7D,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,CAAC;QAC/C,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC,kBAAkB,CAAC;QACvD,IAAI,CAAC,eAAe,GAAG,SAAS,CAAC,eAAe,CAAC;QACjD,IAAI,CAAC,mBAAmB,GAAG,SAAS,CAAC,mBAAmB,CAAC;QACzD,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC,kBAAkB,CAAC;QACvD,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAC,oBAAoB,CAAC;QAC3D,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAC,oBAAoB,CAAC;QAC3D,IAAI,CAAC,qBAAqB,GAAG,SAAS,CAAC,qBAAqB,CAAC;QAC7D,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAC,oBAAoB,CAAC;QAC3D,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,CAAC;QAC/C,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,CAAC;QAC/C,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,CAAC;IACnD,CAAC;CACJ;AA5GD,wBA4GC","sourcesContent":["import * as ros from '@alicloud/ros-cdk-core';\nimport { RosSecret } from './kms.generated';\n// Generated from the AliCloud ROS Resource Specification\nexport { RosSecret as SecretProperty };\n\n/**\n * Properties for defining a `Secret`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secret\n */\nexport interface SecretProps {\n\n    /**\n     * Property secretName: The name of the secret.\n     */\n    readonly secretName: 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 * This class encapsulates and extends the ROS resource type `DATASOURCE::KMS::Secret`.\n * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosSecret`for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-kms-secret\n */\nexport class Secret extends ros.Resource {\n    protected scope: ros.Construct;\n    protected id: string;\n    protected props: SecretProps;\n    protected enableResourcePropertyConstraint: boolean;\n\n    /**\n     * Attribute Arn: The Alibaba Cloud Resource Name (ARN) of the secret.\n     */\n    public readonly attrArn: ros.IResolvable;\n\n    /**\n     * Attribute AutomaticRotation: Indicates whether automatic rotation is enabled.\n     */\n    public readonly attrAutomaticRotation: ros.IResolvable;\n\n    /**\n     * Attribute CreateTime: The time when the secret was created.\n     */\n    public readonly attrCreateTime: ros.IResolvable;\n\n    /**\n     * Attribute DKMSInstanceId: The ID of the dedicated KMS instance.\n     */\n    public readonly attrDkmsInstanceId: ros.IResolvable;\n\n    /**\n     * Attribute Description: The description of the secret.\n     */\n    public readonly attrDescription: ros.IResolvable;\n\n    /**\n     * Attribute EncryptionKeyId: The ID of the customer master key (CMK) that is used to encrypt the secret value.\n     */\n    public readonly attrEncryptionKeyId: ros.IResolvable;\n\n    /**\n     * Attribute ExtendedConfig: The extended configuration of the secret.\n     */\n    public readonly attrExtendedConfig: ros.IResolvable;\n\n    /**\n     * Attribute LastRotationDate: The time when the last rotation was performed.\n     */\n    public readonly attrLastRotationDate: ros.IResolvable;\n\n    /**\n     * Attribute NextRotationDate: The time when the next rotation will be performed.\n     */\n    public readonly attrNextRotationDate: ros.IResolvable;\n\n    /**\n     * Attribute PlannedDeleteTime: The time when the secret is scheduled to be deleted.\n     */\n    public readonly attrPlannedDeleteTime: ros.IResolvable;\n\n    /**\n     * Attribute RotationInterval: The interval for automatic rotation. The value is in the integer[unit] format. integer indicates the length of time. unit: indicates the time unit. The value of unit is fixed as s. For example, if the value is 604800s, automatic rotation is performed at a 7-day interval.The value is in the integer[unit] format. integer indicates the length of time. unit: indicates the time unit. The value of unit is fixed as s. For example, if the value is 604800s, automatic rotation is performed at a 7-day interval.\n     */\n    public readonly attrRotationInterval: ros.IResolvable;\n\n    /**\n     * Attribute SecretName: The name of the secret.\n     */\n    public readonly attrSecretName: ros.IResolvable;\n\n    /**\n     * Attribute SecretType: The type of the secret.\n     */\n    public readonly attrSecretType: ros.IResolvable;\n\n    /**\n     * Attribute UpdateTime: The time when the secret was updated.\n     */\n    public readonly attrUpdateTime: 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: SecretProps, 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 rosSecret = new RosSecret(this, id,  {\n            secretName: props.secretName,\n            refreshOptions: props.refreshOptions === undefined || props.refreshOptions === null ? 'Never' : props.refreshOptions,\n        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);\n        this.resource = rosSecret;\n        this.attrArn = rosSecret.attrArn;\n        this.attrAutomaticRotation = rosSecret.attrAutomaticRotation;\n        this.attrCreateTime = rosSecret.attrCreateTime;\n        this.attrDkmsInstanceId = rosSecret.attrDkmsInstanceId;\n        this.attrDescription = rosSecret.attrDescription;\n        this.attrEncryptionKeyId = rosSecret.attrEncryptionKeyId;\n        this.attrExtendedConfig = rosSecret.attrExtendedConfig;\n        this.attrLastRotationDate = rosSecret.attrLastRotationDate;\n        this.attrNextRotationDate = rosSecret.attrNextRotationDate;\n        this.attrPlannedDeleteTime = rosSecret.attrPlannedDeleteTime;\n        this.attrRotationInterval = rosSecret.attrRotationInterval;\n        this.attrSecretName = rosSecret.attrSecretName;\n        this.attrSecretType = rosSecret.attrSecretType;\n        this.attrUpdateTime = rosSecret.attrUpdateTime;\n    }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alicloud/ros-cdk-kms",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Aliyun SDK Copyright (C) Alibaba Cloud Computing All rights reserved. http://www.aliyun.com",
   "author": "ROS Development Team",
   "license": "Apache-2.0",