@alicloud/ros-cdk-computenest 1.4.0 → 1.6.0

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

@@ -1,4 +1,154 @@
 import * as ros from '@alicloud/ros-cdk-core';
+/**
+ * Properties for defining a `RosServiceInstance`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance
+ */
+export interface RosServiceInstanceProps {
+    /**
+     * @Property serviceInstanceId: The ID of the service instance.
+     */
+    readonly serviceInstanceId: 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::ComputeNest::ServiceInstance`.
+ * @Note This class does not contain additional functions, so it is recommended to use the `ServiceInstance` class instead of this class for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance
+ */
+export declare class RosServiceInstance extends ros.RosResource {
+    /**
+     * The resource type name for this resource class.
+     */
+    static readonly ROS_RESOURCE_TYPE_NAME = "DATASOURCE::ComputeNest::ServiceInstance";
+    /**
+     * @Attribute Components: Cloud Marketplace additional billing items.
+     */
+    readonly attrComponents: ros.IResolvable;
+    /**
+     * @Attribute CreateTime: The time when the serviceInstance was created.
+     */
+    readonly attrCreateTime: ros.IResolvable;
+    /**
+     * @Attribute EnableInstanceOps: Indicates whether the service instance supports the operation feature.
+     */
+    readonly attrEnableInstanceOps: ros.IResolvable;
+    /**
+     * @Attribute EnableUserPrometheus: Whether to enable Prometheus monitoring.
+     */
+    readonly attrEnableUserPrometheus: ros.IResolvable;
+    /**
+     * @Attribute IsOperated: Indicates whether the hosted O&M feature is enabled for the service instance.
+     */
+    readonly attrIsOperated: ros.IResolvable;
+    /**
+     * @Attribute LicenseEndTime: The expiration time of licence.
+     */
+    readonly attrLicenseEndTime: ros.IResolvable;
+    /**
+     * @Attribute MarketInstanceId: The ID of the cloud marketplace instance.
+     */
+    readonly attrMarketInstanceId: ros.IResolvable;
+    /**
+     * @Attribute NetworkConfig: The network configurations.
+     */
+    readonly attrNetworkConfig: ros.IResolvable;
+    /**
+     * @Attribute Outputs: The outputs returned from creating the service instance.
+     */
+    readonly attrOutputs: ros.IResolvable;
+    /**
+     * @Attribute Parameters: The parameters configured for the service instance.
+     */
+    readonly attrParameters: ros.IResolvable;
+    /**
+     * @Attribute PredefinedParameterName: The name of the package .
+     */
+    readonly attrPredefinedParameterName: ros.IResolvable;
+    /**
+     * @Attribute Progress: The deployment progress of the service instance. Unit: percentage.
+     */
+    readonly attrProgress: ros.IResolvable;
+    /**
+     * @Attribute ResourceGroupId: The resource group ID.
+     */
+    readonly attrResourceGroupId: ros.IResolvable;
+    /**
+     * @Attribute Service: The information about the service to which the service instance belongs.
+     */
+    readonly attrService: ros.IResolvable;
+    /**
+     * @Attribute ServiceInstanceId: The ID of the service instance.
+     */
+    readonly attrServiceInstanceId: ros.IResolvable;
+    /**
+     * @Attribute ServiceInstanceName: The name of the resource.
+     */
+    readonly attrServiceInstanceName: ros.IResolvable;
+    /**
+     * @Attribute ServiceType: The type of the service.
+     */
+    readonly attrServiceType: ros.IResolvable;
+    /**
+     * @Attribute Source: The source of the service instance.
+     */
+    readonly attrSource: ros.IResolvable;
+    /**
+     * @Attribute StatusDetail: The description of the deployment state of the service instance.
+     */
+    readonly attrStatusDetail: ros.IResolvable;
+    /**
+     * @Attribute SupplierUid: The Alibaba Cloud account ID of the service provider.
+     */
+    readonly attrSupplierUid: ros.IResolvable;
+    /**
+     * @Attribute Tags: The tags of the service instance.
+     */
+    readonly attrTags: ros.IResolvable;
+    /**
+     * @Attribute TemplateName: The name of the template.
+     */
+    readonly attrTemplateName: ros.IResolvable;
+    /**
+     * @Attribute UpdateTime: The time when the serviceInstance was last updated.
+     */
+    readonly attrUpdateTime: ros.IResolvable;
+    /**
+     * @Attribute UserId: The AliUid of the user.
+     */
+    readonly attrUserId: ros.IResolvable;
+    enableResourcePropertyConstraint: boolean;
+    /**
+     * @Property serviceInstanceId: The ID of the service instance.
+     */
+    serviceInstanceId: 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: RosServiceInstanceProps, enableResourcePropertyConstraint: boolean);
+    protected get rosProperties(): {
+        [key: string]: any;
+    };
+    protected renderProperties(props: {
+        [key: string]: any;
+    }): {
+        [key: string]: any;
+    };
+}
 /**
  * Properties for defining a `RosServiceInstances`.
  * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstances

package/lib/datasource/computenest.generated.js

@@ -1,8 +1,107 @@
 "use strict";
 // Generated from the AliCloud ROS Resource Specification
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RosServiceInstances = void 0;
+exports.RosServiceInstances = exports.RosServiceInstance = void 0;
 const ros = require("@alicloud/ros-cdk-core");
+/**
+ * Determine whether the given properties match those of a `RosServiceInstanceProps`
+ *
+ * @param properties - the TypeScript properties of a `RosServiceInstanceProps`
+ *
+ * @returns the result of the validation.
+ */
+function RosServiceInstancePropsValidator(properties) {
+    if (!ros.canInspect(properties)) {
+        return ros.VALIDATION_SUCCESS;
+    }
+    const errors = new ros.ValidationResults();
+    errors.collect(ros.propertyValidator('serviceInstanceId', ros.requiredValidator)(properties.serviceInstanceId));
+    errors.collect(ros.propertyValidator('serviceInstanceId', ros.validateString)(properties.serviceInstanceId));
+    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 "RosServiceInstanceProps"');
+}
+/**
+ * Renders the AliCloud ROS Resource properties of an `DATASOURCE::ComputeNest::ServiceInstance` resource
+ *
+ * @param properties - the TypeScript properties of a `RosServiceInstanceProps`
+ *
+ * @returns the AliCloud ROS Resource properties of an `DATASOURCE::ComputeNest::ServiceInstance` resource.
+ */
+// @ts-ignore TS6133
+function rosServiceInstancePropsToRosTemplate(properties, enableResourcePropertyConstraint) {
+    if (!ros.canInspect(properties)) {
+        return properties;
+    }
+    if (enableResourcePropertyConstraint) {
+        RosServiceInstancePropsValidator(properties).assertSuccess();
+    }
+    return {
+        'ServiceInstanceId': ros.stringToRosTemplate(properties.serviceInstanceId),
+        'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),
+    };
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `DATASOURCE::ComputeNest::ServiceInstance`.
+ * @Note This class does not contain additional functions, so it is recommended to use the `ServiceInstance` class instead of this class for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance
+ */
+class RosServiceInstance 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: RosServiceInstance.ROS_RESOURCE_TYPE_NAME, properties: props });
+        this.attrComponents = this.getAtt('Components');
+        this.attrCreateTime = this.getAtt('CreateTime');
+        this.attrEnableInstanceOps = this.getAtt('EnableInstanceOps');
+        this.attrEnableUserPrometheus = this.getAtt('EnableUserPrometheus');
+        this.attrIsOperated = this.getAtt('IsOperated');
+        this.attrLicenseEndTime = this.getAtt('LicenseEndTime');
+        this.attrMarketInstanceId = this.getAtt('MarketInstanceId');
+        this.attrNetworkConfig = this.getAtt('NetworkConfig');
+        this.attrOutputs = this.getAtt('Outputs');
+        this.attrParameters = this.getAtt('Parameters');
+        this.attrPredefinedParameterName = this.getAtt('PredefinedParameterName');
+        this.attrProgress = this.getAtt('Progress');
+        this.attrResourceGroupId = this.getAtt('ResourceGroupId');
+        this.attrService = this.getAtt('Service');
+        this.attrServiceInstanceId = this.getAtt('ServiceInstanceId');
+        this.attrServiceInstanceName = this.getAtt('ServiceInstanceName');
+        this.attrServiceType = this.getAtt('ServiceType');
+        this.attrSource = this.getAtt('Source');
+        this.attrStatusDetail = this.getAtt('StatusDetail');
+        this.attrSupplierUid = this.getAtt('SupplierUid');
+        this.attrTags = this.getAtt('Tags');
+        this.attrTemplateName = this.getAtt('TemplateName');
+        this.attrUpdateTime = this.getAtt('UpdateTime');
+        this.attrUserId = this.getAtt('UserId');
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
+        this.serviceInstanceId = props.serviceInstanceId;
+        this.refreshOptions = props.refreshOptions;
+    }
+    get rosProperties() {
+        return {
+            serviceInstanceId: this.serviceInstanceId,
+            refreshOptions: this.refreshOptions,
+        };
+    }
+    renderProperties(props) {
+        return rosServiceInstancePropsToRosTemplate(props, this.enableResourcePropertyConstraint);
+    }
+}
+exports.RosServiceInstance = RosServiceInstance;
+/**
+ * The resource type name for this resource class.
+ */
+RosServiceInstance.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::ComputeNest::ServiceInstance";
 /**
  * Determine whether the given properties match those of a `RosServiceInstancesProps`
  *
@@ -79,4 +178,4 @@ exports.RosServiceInstances = RosServiceInstances;
  * The resource type name for this resource class.
  */
 RosServiceInstances.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::ComputeNest::ServiceInstances";
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"computenest.generated.js","sourceRoot":"","sources":["computenest.generated.ts"],"names":[],"mappings":";AAAA,yDAAyD;;;AAEzD,8CAA8C;AAsB9C;;;;;;GAMG;AACH,SAAS,iCAAiC,CAAC,UAAe;IACtD,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE;QAAE,OAAO,GAAG,CAAC,kBAAkB,CAAC;KAAE;IACnE,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,iBAAiB,EAAE,CAAC;IAC3C,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC;IACzG,IAAG,UAAU,CAAC,cAAc,IAAI,CAAC,OAAO,UAAU,CAAC,cAAc,CAAC,KAAK,QAAQ,EAAE;QAC7E,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,GAAG,CAAC,qBAAqB,CAAC,CAAC;YAChF,IAAI,EAAE,UAAU,CAAC,cAAc;YAC/B,aAAa,EAAE,CAAC,QAAQ,EAAC,OAAO,CAAC;SAClC,CAAC,CAAC,CAAC;KACP;IACD,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC;IACvG,OAAO,MAAM,CAAC,IAAI,CAAC,gEAAgE,CAAC,CAAC;AACzF,CAAC;AAED;;;;;;GAMG;AACH,oBAAoB;AACpB,SAAS,qCAAqC,CAAC,UAAe,EAAE,gCAAyC;IACrG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE;QAAE,OAAO,UAAU,CAAC;KAAE;IACvD,IAAG,gCAAgC,EAAE;QACjC,iCAAiC,CAAC,UAAU,CAAC,CAAC,aAAa,EAAE,CAAC;KACjE;IACD,OAAO;QACL,gBAAgB,EAAE,GAAG,CAAC,mBAAmB,CAAC,UAAU,CAAC,cAAc,CAAC;QACpE,iBAAiB,EAAE,GAAG,CAAC,mBAAmB,CAAC,UAAU,CAAC,eAAe,CAAC;KACvE,CAAC;AACN,CAAC;AAED;;;;GAIG;AACH,MAAa,mBAAoB,SAAQ,GAAG,CAAC,WAAW;IAgCpD;;;;OAIG;IACH,YAAY,KAAoB,EAAE,EAAU,EAAE,KAA+B,EAAE,gCAAyC;QACpH,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,mBAAmB,CAAC,sBAAsB,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1F,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;QAChE,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC;QAE5D,IAAI,CAAC,gCAAgC,GAAG,gCAAgC,CAAC;QACzE,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC;QAC3C,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,eAAe,CAAC;IACjD,CAAC;IAGD,IAAc,aAAa;QACvB,OAAO;YACH,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,eAAe,EAAE,IAAI,CAAC,eAAe;SACxC,CAAC;IACN,CAAC;IACS,gBAAgB,CAAC,KAA2B;QAClD,OAAO,qCAAqC,CAAC,KAAK,EAAE,IAAI,CAAC,gCAAgC,CAAC,CAAC;IAC/F,CAAC;;AAxDL,kDAyDC;AAxDG;;GAEG;AACoB,0CAAsB,GAAG,2CAA2C,CAAC","sourcesContent":["// Generated from the AliCloud ROS Resource Specification\n\nimport * as ros from '@alicloud/ros-cdk-core';\n\n/**\n * Properties for defining a `RosServiceInstances`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstances\n */\nexport interface RosServiceInstancesProps {\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    readonly refreshOptions?: string | ros.IResolvable;\n\n    /**\n     * @Property resourceGroupId: The ID of the resource group.\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosServiceInstancesProps`\n *\n * @param properties - the TypeScript properties of a `RosServiceInstancesProps`\n *\n * @returns the result of the validation.\n */\nfunction RosServiceInstancesPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('resourceGroupId', ros.validateString)(properties.resourceGroupId));\n    if(properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {\n        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({\n          data: properties.refreshOptions,\n          allowedValues: [\"Always\",\"Never\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));\n    return errors.wrap('supplied properties not correct for \"RosServiceInstancesProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::ComputeNest::ServiceInstances` resource\n *\n * @param properties - the TypeScript properties of a `RosServiceInstancesProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::ComputeNest::ServiceInstances` resource.\n */\n// @ts-ignore TS6133\nfunction rosServiceInstancesPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosServiceInstancesPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n      'ResourceGroupId': ros.stringToRosTemplate(properties.resourceGroupId),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::ComputeNest::ServiceInstances`, which is used to query the information about service instances.\n * @Note This class does not contain additional functions, so it is recommended to use the `ServiceInstances` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstances\n */\nexport class RosServiceInstances extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::ComputeNest::ServiceInstances\";\n\n    /**\n     * @Attribute ServiceInstanceIds: The list of service instance IDs.\n     */\n    public readonly attrServiceInstanceIds: ros.IResolvable;\n\n    /**\n     * @Attribute ServiceInstances: The list of service instances.\n     */\n    public readonly attrServiceInstances: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    public refreshOptions: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property resourceGroupId: The ID of the resource group.\n     */\n    public resourceGroupId: string | ros.IResolvable | undefined;\n\n    /**\n     * @param scope - scope in which this resource is defined\n     * @param id    - scoped id of the resource\n     * @param props - resource properties\n     */\n    constructor(scope: ros.Construct, id: string, props: RosServiceInstancesProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosServiceInstances.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrServiceInstanceIds = this.getAtt('ServiceInstanceIds');\n        this.attrServiceInstances = this.getAtt('ServiceInstances');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n        this.resourceGroupId = props.resourceGroupId;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n            resourceGroupId: this.resourceGroupId,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosServiceInstancesPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"computenest.generated.js","sourceRoot":"","sources":["computenest.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 `RosServiceInstance`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance\n */\nexport interface RosServiceInstanceProps {\n\n    /**\n     * @Property serviceInstanceId: The ID of the service instance.\n     */\n    readonly serviceInstanceId: 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 `RosServiceInstanceProps`\n *\n * @param properties - the TypeScript properties of a `RosServiceInstanceProps`\n *\n * @returns the result of the validation.\n */\nfunction RosServiceInstancePropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('serviceInstanceId', ros.requiredValidator)(properties.serviceInstanceId));\n    errors.collect(ros.propertyValidator('serviceInstanceId', ros.validateString)(properties.serviceInstanceId));\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 \"RosServiceInstanceProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::ComputeNest::ServiceInstance` resource\n *\n * @param properties - the TypeScript properties of a `RosServiceInstanceProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::ComputeNest::ServiceInstance` resource.\n */\n// @ts-ignore TS6133\nfunction rosServiceInstancePropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosServiceInstancePropsValidator(properties).assertSuccess();\n    }\n    return {\n      'ServiceInstanceId': ros.stringToRosTemplate(properties.serviceInstanceId),\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::ComputeNest::ServiceInstance`.\n * @Note This class does not contain additional functions, so it is recommended to use the `ServiceInstance` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance\n */\nexport class RosServiceInstance extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::ComputeNest::ServiceInstance\";\n\n    /**\n     * @Attribute Components: Cloud Marketplace additional billing items.\n     */\n    public readonly attrComponents: ros.IResolvable;\n\n    /**\n     * @Attribute CreateTime: The time when the serviceInstance was created.\n     */\n    public readonly attrCreateTime: ros.IResolvable;\n\n    /**\n     * @Attribute EnableInstanceOps: Indicates whether the service instance supports the operation feature.\n     */\n    public readonly attrEnableInstanceOps: ros.IResolvable;\n\n    /**\n     * @Attribute EnableUserPrometheus: Whether to enable Prometheus monitoring.\n     */\n    public readonly attrEnableUserPrometheus: ros.IResolvable;\n\n    /**\n     * @Attribute IsOperated: Indicates whether the hosted O&M feature is enabled for the service instance.\n     */\n    public readonly attrIsOperated: ros.IResolvable;\n\n    /**\n     * @Attribute LicenseEndTime: The expiration time of licence.\n     */\n    public readonly attrLicenseEndTime: ros.IResolvable;\n\n    /**\n     * @Attribute MarketInstanceId: The ID of the cloud marketplace instance.\n     */\n    public readonly attrMarketInstanceId: ros.IResolvable;\n\n    /**\n     * @Attribute NetworkConfig: The network configurations.\n     */\n    public readonly attrNetworkConfig: ros.IResolvable;\n\n    /**\n     * @Attribute Outputs: The outputs returned from creating the service instance.\n     */\n    public readonly attrOutputs: ros.IResolvable;\n\n    /**\n     * @Attribute Parameters: The parameters configured for the service instance.\n     */\n    public readonly attrParameters: ros.IResolvable;\n\n    /**\n     * @Attribute PredefinedParameterName: The name of the package .\n     */\n    public readonly attrPredefinedParameterName: ros.IResolvable;\n\n    /**\n     * @Attribute Progress: The deployment progress of the service instance. Unit: percentage.\n     */\n    public readonly attrProgress: ros.IResolvable;\n\n    /**\n     * @Attribute ResourceGroupId: The resource group ID.\n     */\n    public readonly attrResourceGroupId: ros.IResolvable;\n\n    /**\n     * @Attribute Service: The information about the service to which the service instance belongs.\n     */\n    public readonly attrService: ros.IResolvable;\n\n    /**\n     * @Attribute ServiceInstanceId: The ID of the service instance.\n     */\n    public readonly attrServiceInstanceId: ros.IResolvable;\n\n    /**\n     * @Attribute ServiceInstanceName: The name of the resource.\n     */\n    public readonly attrServiceInstanceName: ros.IResolvable;\n\n    /**\n     * @Attribute ServiceType: The type of the service.\n     */\n    public readonly attrServiceType: ros.IResolvable;\n\n    /**\n     * @Attribute Source: The source of the service instance.\n     */\n    public readonly attrSource: ros.IResolvable;\n\n    /**\n     * @Attribute StatusDetail: The description of the deployment state of the service instance.\n     */\n    public readonly attrStatusDetail: ros.IResolvable;\n\n    /**\n     * @Attribute SupplierUid: The Alibaba Cloud account ID of the service provider.\n     */\n    public readonly attrSupplierUid: ros.IResolvable;\n\n    /**\n     * @Attribute Tags: The tags of the service instance.\n     */\n    public readonly attrTags: ros.IResolvable;\n\n    /**\n     * @Attribute TemplateName: The name of the template.\n     */\n    public readonly attrTemplateName: ros.IResolvable;\n\n    /**\n     * @Attribute UpdateTime: The time when the serviceInstance was last updated.\n     */\n    public readonly attrUpdateTime: ros.IResolvable;\n\n    /**\n     * @Attribute UserId: The AliUid of the user.\n     */\n    public readonly attrUserId: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property serviceInstanceId: The ID of the service instance.\n     */\n    public serviceInstanceId: 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: RosServiceInstanceProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosServiceInstance.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrComponents = this.getAtt('Components');\n        this.attrCreateTime = this.getAtt('CreateTime');\n        this.attrEnableInstanceOps = this.getAtt('EnableInstanceOps');\n        this.attrEnableUserPrometheus = this.getAtt('EnableUserPrometheus');\n        this.attrIsOperated = this.getAtt('IsOperated');\n        this.attrLicenseEndTime = this.getAtt('LicenseEndTime');\n        this.attrMarketInstanceId = this.getAtt('MarketInstanceId');\n        this.attrNetworkConfig = this.getAtt('NetworkConfig');\n        this.attrOutputs = this.getAtt('Outputs');\n        this.attrParameters = this.getAtt('Parameters');\n        this.attrPredefinedParameterName = this.getAtt('PredefinedParameterName');\n        this.attrProgress = this.getAtt('Progress');\n        this.attrResourceGroupId = this.getAtt('ResourceGroupId');\n        this.attrService = this.getAtt('Service');\n        this.attrServiceInstanceId = this.getAtt('ServiceInstanceId');\n        this.attrServiceInstanceName = this.getAtt('ServiceInstanceName');\n        this.attrServiceType = this.getAtt('ServiceType');\n        this.attrSource = this.getAtt('Source');\n        this.attrStatusDetail = this.getAtt('StatusDetail');\n        this.attrSupplierUid = this.getAtt('SupplierUid');\n        this.attrTags = this.getAtt('Tags');\n        this.attrTemplateName = this.getAtt('TemplateName');\n        this.attrUpdateTime = this.getAtt('UpdateTime');\n        this.attrUserId = this.getAtt('UserId');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.serviceInstanceId = props.serviceInstanceId;\n        this.refreshOptions = props.refreshOptions;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            serviceInstanceId: this.serviceInstanceId,\n            refreshOptions: this.refreshOptions,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosServiceInstancePropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosServiceInstances`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstances\n */\nexport interface RosServiceInstancesProps {\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    readonly refreshOptions?: string | ros.IResolvable;\n\n    /**\n     * @Property resourceGroupId: The ID of the resource group.\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosServiceInstancesProps`\n *\n * @param properties - the TypeScript properties of a `RosServiceInstancesProps`\n *\n * @returns the result of the validation.\n */\nfunction RosServiceInstancesPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('resourceGroupId', ros.validateString)(properties.resourceGroupId));\n    if(properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {\n        errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({\n          data: properties.refreshOptions,\n          allowedValues: [\"Always\",\"Never\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));\n    return errors.wrap('supplied properties not correct for \"RosServiceInstancesProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::ComputeNest::ServiceInstances` resource\n *\n * @param properties - the TypeScript properties of a `RosServiceInstancesProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::ComputeNest::ServiceInstances` resource.\n */\n// @ts-ignore TS6133\nfunction rosServiceInstancesPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosServiceInstancesPropsValidator(properties).assertSuccess();\n    }\n    return {\n      'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),\n      'ResourceGroupId': ros.stringToRosTemplate(properties.resourceGroupId),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `DATASOURCE::ComputeNest::ServiceInstances`, which is used to query the information about service instances.\n * @Note This class does not contain additional functions, so it is recommended to use the `ServiceInstances` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstances\n */\nexport class RosServiceInstances extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::ComputeNest::ServiceInstances\";\n\n    /**\n     * @Attribute ServiceInstanceIds: The list of service instance IDs.\n     */\n    public readonly attrServiceInstanceIds: ros.IResolvable;\n\n    /**\n     * @Attribute ServiceInstances: The list of service instances.\n     */\n    public readonly attrServiceInstances: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:\n     * - Never: Never refresh the datasource resource when the stack is updated.\n     * - Always: Always refresh the datasource resource when the stack is updated.\n     * Default is Never.\n     */\n    public refreshOptions: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property resourceGroupId: The ID of the resource group.\n     */\n    public resourceGroupId: string | ros.IResolvable | undefined;\n\n    /**\n     * @param scope - scope in which this resource is defined\n     * @param id    - scoped id of the resource\n     * @param props - resource properties\n     */\n    constructor(scope: ros.Construct, id: string, props: RosServiceInstancesProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosServiceInstances.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrServiceInstanceIds = this.getAtt('ServiceInstanceIds');\n        this.attrServiceInstances = this.getAtt('ServiceInstances');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.refreshOptions = props.refreshOptions;\n        this.resourceGroupId = props.resourceGroupId;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            refreshOptions: this.refreshOptions,\n            resourceGroupId: this.resourceGroupId,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosServiceInstancesPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n"]}

package/lib/datasource/index.d.ts

@@ -1,2 +1,3 @@
+export * from './serviceinstance';
 export * from './serviceinstances';
 export * from './computenest.generated';

package/lib/datasource/index.js

@@ -10,7 +10,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./serviceinstance"), exports);
 __exportStar(require("./serviceinstances"), exports);
 // DATASOURCE::ComputeNest Resources:
 __exportStar(require("./computenest.generated"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSxxREFBbUM7QUFFbkMscUNBQXFDO0FBQ3JDLDBEQUF3QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2VydmljZWluc3RhbmNlcyc7XG5cbi8vIERBVEFTT1VSQ0U6OkNvbXB1dGVOZXN0IFJlc291cmNlczpcbmV4cG9ydCAqIGZyb20gJy4vY29tcHV0ZW5lc3QuZ2VuZXJhdGVkJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSxvREFBa0M7QUFDbEMscURBQW1DO0FBRW5DLHFDQUFxQztBQUNyQywwREFBd0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NlcnZpY2VpbnN0YW5jZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VpbnN0YW5jZXMnO1xuXG4vLyBEQVRBU09VUkNFOjpDb21wdXRlTmVzdCBSZXNvdXJjZXM6XG5leHBvcnQgKiBmcm9tICcuL2NvbXB1dGVuZXN0LmdlbmVyYXRlZCc7XG4iXX0=

package/lib/datasource/serviceinstance.d.ts

@@ -0,0 +1,235 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosServiceInstance } from './computenest.generated';
+export { RosServiceInstance as ServiceInstanceProperty };
+/**
+ * Properties for defining a `ServiceInstance`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance
+ */
+export interface ServiceInstanceProps {
+    /**
+     * Property serviceInstanceId: The ID of the service instance.
+     */
+    readonly serviceInstanceId: 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;
+}
+/**
+ * Represents a `ServiceInstance`.
+ */
+export interface IServiceInstance extends ros.IResource {
+    readonly props: ServiceInstanceProps;
+    /**
+     * Attribute Components: Cloud Marketplace additional billing items.
+     */
+    readonly attrComponents: ros.IResolvable | string;
+    /**
+     * Attribute CreateTime: The time when the serviceInstance was created.
+     */
+    readonly attrCreateTime: ros.IResolvable | string;
+    /**
+     * Attribute EnableInstanceOps: Indicates whether the service instance supports the operation feature.
+     */
+    readonly attrEnableInstanceOps: ros.IResolvable | string;
+    /**
+     * Attribute EnableUserPrometheus: Whether to enable Prometheus monitoring.
+     */
+    readonly attrEnableUserPrometheus: ros.IResolvable | string;
+    /**
+     * Attribute IsOperated: Indicates whether the hosted O&M feature is enabled for the service instance.
+     */
+    readonly attrIsOperated: ros.IResolvable | string;
+    /**
+     * Attribute LicenseEndTime: The expiration time of licence.
+     */
+    readonly attrLicenseEndTime: ros.IResolvable | string;
+    /**
+     * Attribute MarketInstanceId: The ID of the cloud marketplace instance.
+     */
+    readonly attrMarketInstanceId: ros.IResolvable | string;
+    /**
+     * Attribute NetworkConfig: The network configurations.
+     */
+    readonly attrNetworkConfig: ros.IResolvable | string;
+    /**
+     * Attribute Outputs: The outputs returned from creating the service instance.
+     */
+    readonly attrOutputs: ros.IResolvable | string;
+    /**
+     * Attribute Parameters: The parameters configured for the service instance.
+     */
+    readonly attrParameters: ros.IResolvable | string;
+    /**
+     * Attribute PredefinedParameterName: The name of the package .
+     */
+    readonly attrPredefinedParameterName: ros.IResolvable | string;
+    /**
+     * Attribute Progress: The deployment progress of the service instance. Unit: percentage.
+     */
+    readonly attrProgress: ros.IResolvable | string;
+    /**
+     * Attribute ResourceGroupId: The resource group ID.
+     */
+    readonly attrResourceGroupId: ros.IResolvable | string;
+    /**
+     * Attribute Service: The information about the service to which the service instance belongs.
+     */
+    readonly attrService: ros.IResolvable | string;
+    /**
+     * Attribute ServiceInstanceId: The ID of the service instance.
+     */
+    readonly attrServiceInstanceId: ros.IResolvable | string;
+    /**
+     * Attribute ServiceInstanceName: The name of the resource.
+     */
+    readonly attrServiceInstanceName: ros.IResolvable | string;
+    /**
+     * Attribute ServiceType: The type of the service.
+     */
+    readonly attrServiceType: ros.IResolvable | string;
+    /**
+     * Attribute Source: The source of the service instance.
+     */
+    readonly attrSource: ros.IResolvable | string;
+    /**
+     * Attribute StatusDetail: The description of the deployment state of the service instance.
+     */
+    readonly attrStatusDetail: ros.IResolvable | string;
+    /**
+     * Attribute SupplierUid: The Alibaba Cloud account ID of the service provider.
+     */
+    readonly attrSupplierUid: ros.IResolvable | string;
+    /**
+     * Attribute Tags: The tags of the service instance.
+     */
+    readonly attrTags: ros.IResolvable | string;
+    /**
+     * Attribute TemplateName: The name of the template.
+     */
+    readonly attrTemplateName: ros.IResolvable | string;
+    /**
+     * Attribute UpdateTime: The time when the serviceInstance was last updated.
+     */
+    readonly attrUpdateTime: ros.IResolvable | string;
+    /**
+     * Attribute UserId: The AliUid of the user.
+     */
+    readonly attrUserId: ros.IResolvable | string;
+}
+/**
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::ComputeNest::ServiceInstance`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosServiceInstance`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance
+ */
+export declare class ServiceInstance extends ros.Resource implements IServiceInstance {
+    protected scope: ros.Construct;
+    protected id: string;
+    readonly props: ServiceInstanceProps;
+    protected enableResourcePropertyConstraint: boolean;
+    /**
+     * Attribute Components: Cloud Marketplace additional billing items.
+     */
+    readonly attrComponents: ros.IResolvable | string;
+    /**
+     * Attribute CreateTime: The time when the serviceInstance was created.
+     */
+    readonly attrCreateTime: ros.IResolvable | string;
+    /**
+     * Attribute EnableInstanceOps: Indicates whether the service instance supports the operation feature.
+     */
+    readonly attrEnableInstanceOps: ros.IResolvable | string;
+    /**
+     * Attribute EnableUserPrometheus: Whether to enable Prometheus monitoring.
+     */
+    readonly attrEnableUserPrometheus: ros.IResolvable | string;
+    /**
+     * Attribute IsOperated: Indicates whether the hosted O&M feature is enabled for the service instance.
+     */
+    readonly attrIsOperated: ros.IResolvable | string;
+    /**
+     * Attribute LicenseEndTime: The expiration time of licence.
+     */
+    readonly attrLicenseEndTime: ros.IResolvable | string;
+    /**
+     * Attribute MarketInstanceId: The ID of the cloud marketplace instance.
+     */
+    readonly attrMarketInstanceId: ros.IResolvable | string;
+    /**
+     * Attribute NetworkConfig: The network configurations.
+     */
+    readonly attrNetworkConfig: ros.IResolvable | string;
+    /**
+     * Attribute Outputs: The outputs returned from creating the service instance.
+     */
+    readonly attrOutputs: ros.IResolvable | string;
+    /**
+     * Attribute Parameters: The parameters configured for the service instance.
+     */
+    readonly attrParameters: ros.IResolvable | string;
+    /**
+     * Attribute PredefinedParameterName: The name of the package .
+     */
+    readonly attrPredefinedParameterName: ros.IResolvable | string;
+    /**
+     * Attribute Progress: The deployment progress of the service instance. Unit: percentage.
+     */
+    readonly attrProgress: ros.IResolvable | string;
+    /**
+     * Attribute ResourceGroupId: The resource group ID.
+     */
+    readonly attrResourceGroupId: ros.IResolvable | string;
+    /**
+     * Attribute Service: The information about the service to which the service instance belongs.
+     */
+    readonly attrService: ros.IResolvable | string;
+    /**
+     * Attribute ServiceInstanceId: The ID of the service instance.
+     */
+    readonly attrServiceInstanceId: ros.IResolvable | string;
+    /**
+     * Attribute ServiceInstanceName: The name of the resource.
+     */
+    readonly attrServiceInstanceName: ros.IResolvable | string;
+    /**
+     * Attribute ServiceType: The type of the service.
+     */
+    readonly attrServiceType: ros.IResolvable | string;
+    /**
+     * Attribute Source: The source of the service instance.
+     */
+    readonly attrSource: ros.IResolvable | string;
+    /**
+     * Attribute StatusDetail: The description of the deployment state of the service instance.
+     */
+    readonly attrStatusDetail: ros.IResolvable | string;
+    /**
+     * Attribute SupplierUid: The Alibaba Cloud account ID of the service provider.
+     */
+    readonly attrSupplierUid: ros.IResolvable | string;
+    /**
+     * Attribute Tags: The tags of the service instance.
+     */
+    readonly attrTags: ros.IResolvable | string;
+    /**
+     * Attribute TemplateName: The name of the template.
+     */
+    readonly attrTemplateName: ros.IResolvable | string;
+    /**
+     * Attribute UpdateTime: The time when the serviceInstance was last updated.
+     */
+    readonly attrUpdateTime: ros.IResolvable | string;
+    /**
+     * Attribute UserId: The AliUid of the user.
+     */
+    readonly attrUserId: ros.IResolvable | string;
+    /**
+     * 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: ServiceInstanceProps, enableResourcePropertyConstraint?: boolean);
+}

package/lib/datasource/serviceinstance.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceInstance = exports.ServiceInstanceProperty = void 0;
+const ros = require("@alicloud/ros-cdk-core");
+const computenest_generated_1 = require("./computenest.generated");
+Object.defineProperty(exports, "ServiceInstanceProperty", { enumerable: true, get: function () { return computenest_generated_1.RosServiceInstance; } });
+/**
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::ComputeNest::ServiceInstance`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosServiceInstance`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance
+ */
+class ServiceInstance 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 rosServiceInstance = new computenest_generated_1.RosServiceInstance(this, id, {
+            serviceInstanceId: props.serviceInstanceId,
+            refreshOptions: props.refreshOptions === undefined || props.refreshOptions === null ? 'Never' : props.refreshOptions,
+        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
+        this.resource = rosServiceInstance;
+        this.attrComponents = rosServiceInstance.attrComponents;
+        this.attrCreateTime = rosServiceInstance.attrCreateTime;
+        this.attrEnableInstanceOps = rosServiceInstance.attrEnableInstanceOps;
+        this.attrEnableUserPrometheus = rosServiceInstance.attrEnableUserPrometheus;
+        this.attrIsOperated = rosServiceInstance.attrIsOperated;
+        this.attrLicenseEndTime = rosServiceInstance.attrLicenseEndTime;
+        this.attrMarketInstanceId = rosServiceInstance.attrMarketInstanceId;
+        this.attrNetworkConfig = rosServiceInstance.attrNetworkConfig;
+        this.attrOutputs = rosServiceInstance.attrOutputs;
+        this.attrParameters = rosServiceInstance.attrParameters;
+        this.attrPredefinedParameterName = rosServiceInstance.attrPredefinedParameterName;
+        this.attrProgress = rosServiceInstance.attrProgress;
+        this.attrResourceGroupId = rosServiceInstance.attrResourceGroupId;
+        this.attrService = rosServiceInstance.attrService;
+        this.attrServiceInstanceId = rosServiceInstance.attrServiceInstanceId;
+        this.attrServiceInstanceName = rosServiceInstance.attrServiceInstanceName;
+        this.attrServiceType = rosServiceInstance.attrServiceType;
+        this.attrSource = rosServiceInstance.attrSource;
+        this.attrStatusDetail = rosServiceInstance.attrStatusDetail;
+        this.attrSupplierUid = rosServiceInstance.attrSupplierUid;
+        this.attrTags = rosServiceInstance.attrTags;
+        this.attrTemplateName = rosServiceInstance.attrTemplateName;
+        this.attrUpdateTime = rosServiceInstance.attrUpdateTime;
+        this.attrUserId = rosServiceInstance.attrUserId;
+    }
+}
+exports.ServiceInstance = ServiceInstance;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serviceinstance.js","sourceRoot":"","sources":["serviceinstance.ts"],"names":[],"mappings":";;;AAAA,8CAA8C;AAC9C,mEAA6D;AAE9B,wGAFtB,0CAAkB,OAE2B;AAoJtD;;;;GAIG;AACH,MAAa,eAAgB,SAAQ,GAAG,CAAC,QAAQ;IA8H7C;;;;OAIG;IACH,YAAY,KAAoB,EAAE,EAAU,EAAE,KAA2B,EAAE,mCAA2C,IAAI;QACtH,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,kBAAkB,GAAG,IAAI,0CAAkB,CAAC,IAAI,EAAE,EAAE,EAAG;YACzD,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;YAC1C,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,kBAAkB,CAAC;QACnC,IAAI,CAAC,cAAc,GAAG,kBAAkB,CAAC,cAAc,CAAC;QACxD,IAAI,CAAC,cAAc,GAAG,kBAAkB,CAAC,cAAc,CAAC;QACxD,IAAI,CAAC,qBAAqB,GAAG,kBAAkB,CAAC,qBAAqB,CAAC;QACtE,IAAI,CAAC,wBAAwB,GAAG,kBAAkB,CAAC,wBAAwB,CAAC;QAC5E,IAAI,CAAC,cAAc,GAAG,kBAAkB,CAAC,cAAc,CAAC;QACxD,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC,kBAAkB,CAAC;QAChE,IAAI,CAAC,oBAAoB,GAAG,kBAAkB,CAAC,oBAAoB,CAAC;QACpE,IAAI,CAAC,iBAAiB,GAAG,kBAAkB,CAAC,iBAAiB,CAAC;QAC9D,IAAI,CAAC,WAAW,GAAG,kBAAkB,CAAC,WAAW,CAAC;QAClD,IAAI,CAAC,cAAc,GAAG,kBAAkB,CAAC,cAAc,CAAC;QACxD,IAAI,CAAC,2BAA2B,GAAG,kBAAkB,CAAC,2BAA2B,CAAC;QAClF,IAAI,CAAC,YAAY,GAAG,kBAAkB,CAAC,YAAY,CAAC;QACpD,IAAI,CAAC,mBAAmB,GAAG,kBAAkB,CAAC,mBAAmB,CAAC;QAClE,IAAI,CAAC,WAAW,GAAG,kBAAkB,CAAC,WAAW,CAAC;QAClD,IAAI,CAAC,qBAAqB,GAAG,kBAAkB,CAAC,qBAAqB,CAAC;QACtE,IAAI,CAAC,uBAAuB,GAAG,kBAAkB,CAAC,uBAAuB,CAAC;QAC1E,IAAI,CAAC,eAAe,GAAG,kBAAkB,CAAC,eAAe,CAAC;QAC1D,IAAI,CAAC,UAAU,GAAG,kBAAkB,CAAC,UAAU,CAAC;QAChD,IAAI,CAAC,gBAAgB,GAAG,kBAAkB,CAAC,gBAAgB,CAAC;QAC5D,IAAI,CAAC,eAAe,GAAG,kBAAkB,CAAC,eAAe,CAAC;QAC1D,IAAI,CAAC,QAAQ,GAAG,kBAAkB,CAAC,QAAQ,CAAC;QAC5C,IAAI,CAAC,gBAAgB,GAAG,kBAAkB,CAAC,gBAAgB,CAAC;QAC5D,IAAI,CAAC,cAAc,GAAG,kBAAkB,CAAC,cAAc,CAAC;QACxD,IAAI,CAAC,UAAU,GAAG,kBAAkB,CAAC,UAAU,CAAC;IACpD,CAAC;CACJ;AAxKD,0CAwKC","sourcesContent":["import * as ros from '@alicloud/ros-cdk-core';\nimport { RosServiceInstance } from './computenest.generated';\n// Generated from the AliCloud ROS Resource Specification\nexport { RosServiceInstance as ServiceInstanceProperty };\n\n/**\n * Properties for defining a `ServiceInstance`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance\n */\nexport interface ServiceInstanceProps {\n\n    /**\n     * Property serviceInstanceId: The ID of the service instance.\n     */\n    readonly serviceInstanceId: 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 * Represents a `ServiceInstance`.\n */\nexport interface IServiceInstance extends ros.IResource {\n    readonly props: ServiceInstanceProps;\n\n    /**\n     * Attribute Components: Cloud Marketplace additional billing items.\n     */\n    readonly attrComponents: ros.IResolvable | string;\n\n    /**\n     * Attribute CreateTime: The time when the serviceInstance was created.\n     */\n    readonly attrCreateTime: ros.IResolvable | string;\n\n    /**\n     * Attribute EnableInstanceOps: Indicates whether the service instance supports the operation feature.\n     */\n    readonly attrEnableInstanceOps: ros.IResolvable | string;\n\n    /**\n     * Attribute EnableUserPrometheus: Whether to enable Prometheus monitoring.\n     */\n    readonly attrEnableUserPrometheus: ros.IResolvable | string;\n\n    /**\n     * Attribute IsOperated: Indicates whether the hosted O&M feature is enabled for the service instance.\n     */\n    readonly attrIsOperated: ros.IResolvable | string;\n\n    /**\n     * Attribute LicenseEndTime: The expiration time of licence.\n     */\n    readonly attrLicenseEndTime: ros.IResolvable | string;\n\n    /**\n     * Attribute MarketInstanceId: The ID of the cloud marketplace instance.\n     */\n    readonly attrMarketInstanceId: ros.IResolvable | string;\n\n    /**\n     * Attribute NetworkConfig: The network configurations.\n     */\n    readonly attrNetworkConfig: ros.IResolvable | string;\n\n    /**\n     * Attribute Outputs: The outputs returned from creating the service instance.\n     */\n    readonly attrOutputs: ros.IResolvable | string;\n\n    /**\n     * Attribute Parameters: The parameters configured for the service instance.\n     */\n    readonly attrParameters: ros.IResolvable | string;\n\n    /**\n     * Attribute PredefinedParameterName: The name of the package .\n     */\n    readonly attrPredefinedParameterName: ros.IResolvable | string;\n\n    /**\n     * Attribute Progress: The deployment progress of the service instance. Unit: percentage.\n     */\n    readonly attrProgress: ros.IResolvable | string;\n\n    /**\n     * Attribute ResourceGroupId: The resource group ID.\n     */\n    readonly attrResourceGroupId: ros.IResolvable | string;\n\n    /**\n     * Attribute Service: The information about the service to which the service instance belongs.\n     */\n    readonly attrService: ros.IResolvable | string;\n\n    /**\n     * Attribute ServiceInstanceId: The ID of the service instance.\n     */\n    readonly attrServiceInstanceId: ros.IResolvable | string;\n\n    /**\n     * Attribute ServiceInstanceName: The name of the resource.\n     */\n    readonly attrServiceInstanceName: ros.IResolvable | string;\n\n    /**\n     * Attribute ServiceType: The type of the service.\n     */\n    readonly attrServiceType: ros.IResolvable | string;\n\n    /**\n     * Attribute Source: The source of the service instance.\n     */\n    readonly attrSource: ros.IResolvable | string;\n\n    /**\n     * Attribute StatusDetail: The description of the deployment state of the service instance.\n     */\n    readonly attrStatusDetail: ros.IResolvable | string;\n\n    /**\n     * Attribute SupplierUid: The Alibaba Cloud account ID of the service provider.\n     */\n    readonly attrSupplierUid: ros.IResolvable | string;\n\n    /**\n     * Attribute Tags: The tags of the service instance.\n     */\n    readonly attrTags: ros.IResolvable | string;\n\n    /**\n     * Attribute TemplateName: The name of the template.\n     */\n    readonly attrTemplateName: ros.IResolvable | string;\n\n    /**\n     * Attribute UpdateTime: The time when the serviceInstance was last updated.\n     */\n    readonly attrUpdateTime: ros.IResolvable | string;\n\n    /**\n     * Attribute UserId: The AliUid of the user.\n     */\n    readonly attrUserId: ros.IResolvable | string;\n}\n/**\n * This class encapsulates and extends the ROS resource type `DATASOURCE::ComputeNest::ServiceInstance`.\n * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosServiceInstance`for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance\n */\nexport class ServiceInstance extends ros.Resource implements IServiceInstance {\n    protected scope: ros.Construct;\n    protected id: string;\n    public readonly props: ServiceInstanceProps;\n    protected enableResourcePropertyConstraint: boolean;\n\n    /**\n     * Attribute Components: Cloud Marketplace additional billing items.\n     */\n    public readonly attrComponents: ros.IResolvable | string;\n\n    /**\n     * Attribute CreateTime: The time when the serviceInstance was created.\n     */\n    public readonly attrCreateTime: ros.IResolvable | string;\n\n    /**\n     * Attribute EnableInstanceOps: Indicates whether the service instance supports the operation feature.\n     */\n    public readonly attrEnableInstanceOps: ros.IResolvable | string;\n\n    /**\n     * Attribute EnableUserPrometheus: Whether to enable Prometheus monitoring.\n     */\n    public readonly attrEnableUserPrometheus: ros.IResolvable | string;\n\n    /**\n     * Attribute IsOperated: Indicates whether the hosted O&M feature is enabled for the service instance.\n     */\n    public readonly attrIsOperated: ros.IResolvable | string;\n\n    /**\n     * Attribute LicenseEndTime: The expiration time of licence.\n     */\n    public readonly attrLicenseEndTime: ros.IResolvable | string;\n\n    /**\n     * Attribute MarketInstanceId: The ID of the cloud marketplace instance.\n     */\n    public readonly attrMarketInstanceId: ros.IResolvable | string;\n\n    /**\n     * Attribute NetworkConfig: The network configurations.\n     */\n    public readonly attrNetworkConfig: ros.IResolvable | string;\n\n    /**\n     * Attribute Outputs: The outputs returned from creating the service instance.\n     */\n    public readonly attrOutputs: ros.IResolvable | string;\n\n    /**\n     * Attribute Parameters: The parameters configured for the service instance.\n     */\n    public readonly attrParameters: ros.IResolvable | string;\n\n    /**\n     * Attribute PredefinedParameterName: The name of the package .\n     */\n    public readonly attrPredefinedParameterName: ros.IResolvable | string;\n\n    /**\n     * Attribute Progress: The deployment progress of the service instance. Unit: percentage.\n     */\n    public readonly attrProgress: ros.IResolvable | string;\n\n    /**\n     * Attribute ResourceGroupId: The resource group ID.\n     */\n    public readonly attrResourceGroupId: ros.IResolvable | string;\n\n    /**\n     * Attribute Service: The information about the service to which the service instance belongs.\n     */\n    public readonly attrService: ros.IResolvable | string;\n\n    /**\n     * Attribute ServiceInstanceId: The ID of the service instance.\n     */\n    public readonly attrServiceInstanceId: ros.IResolvable | string;\n\n    /**\n     * Attribute ServiceInstanceName: The name of the resource.\n     */\n    public readonly attrServiceInstanceName: ros.IResolvable | string;\n\n    /**\n     * Attribute ServiceType: The type of the service.\n     */\n    public readonly attrServiceType: ros.IResolvable | string;\n\n    /**\n     * Attribute Source: The source of the service instance.\n     */\n    public readonly attrSource: ros.IResolvable | string;\n\n    /**\n     * Attribute StatusDetail: The description of the deployment state of the service instance.\n     */\n    public readonly attrStatusDetail: ros.IResolvable | string;\n\n    /**\n     * Attribute SupplierUid: The Alibaba Cloud account ID of the service provider.\n     */\n    public readonly attrSupplierUid: ros.IResolvable | string;\n\n    /**\n     * Attribute Tags: The tags of the service instance.\n     */\n    public readonly attrTags: ros.IResolvable | string;\n\n    /**\n     * Attribute TemplateName: The name of the template.\n     */\n    public readonly attrTemplateName: ros.IResolvable | string;\n\n    /**\n     * Attribute UpdateTime: The time when the serviceInstance was last updated.\n     */\n    public readonly attrUpdateTime: ros.IResolvable | string;\n\n    /**\n     * Attribute UserId: The AliUid of the user.\n     */\n    public readonly attrUserId: ros.IResolvable | string;\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: ServiceInstanceProps, 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 rosServiceInstance = new RosServiceInstance(this, id,  {\n            serviceInstanceId: props.serviceInstanceId,\n            refreshOptions: props.refreshOptions === undefined || props.refreshOptions === null ? 'Never' : props.refreshOptions,\n        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);\n        this.resource = rosServiceInstance;\n        this.attrComponents = rosServiceInstance.attrComponents;\n        this.attrCreateTime = rosServiceInstance.attrCreateTime;\n        this.attrEnableInstanceOps = rosServiceInstance.attrEnableInstanceOps;\n        this.attrEnableUserPrometheus = rosServiceInstance.attrEnableUserPrometheus;\n        this.attrIsOperated = rosServiceInstance.attrIsOperated;\n        this.attrLicenseEndTime = rosServiceInstance.attrLicenseEndTime;\n        this.attrMarketInstanceId = rosServiceInstance.attrMarketInstanceId;\n        this.attrNetworkConfig = rosServiceInstance.attrNetworkConfig;\n        this.attrOutputs = rosServiceInstance.attrOutputs;\n        this.attrParameters = rosServiceInstance.attrParameters;\n        this.attrPredefinedParameterName = rosServiceInstance.attrPredefinedParameterName;\n        this.attrProgress = rosServiceInstance.attrProgress;\n        this.attrResourceGroupId = rosServiceInstance.attrResourceGroupId;\n        this.attrService = rosServiceInstance.attrService;\n        this.attrServiceInstanceId = rosServiceInstance.attrServiceInstanceId;\n        this.attrServiceInstanceName = rosServiceInstance.attrServiceInstanceName;\n        this.attrServiceType = rosServiceInstance.attrServiceType;\n        this.attrSource = rosServiceInstance.attrSource;\n        this.attrStatusDetail = rosServiceInstance.attrStatusDetail;\n        this.attrSupplierUid = rosServiceInstance.attrSupplierUid;\n        this.attrTags = rosServiceInstance.attrTags;\n        this.attrTemplateName = rosServiceInstance.attrTemplateName;\n        this.attrUpdateTime = rosServiceInstance.attrUpdateTime;\n        this.attrUserId = rosServiceInstance.attrUserId;\n    }\n}\n"]}

package/lib/datasource/serviceinstances.d.ts

@@ -18,24 +18,38 @@ export interface ServiceInstancesProps {
      */
     readonly resourceGroupId?: string | ros.IResolvable;
 }
+/**
+ * Represents a `ServiceInstances`.
+ */
+export interface IServiceInstances extends ros.IResource {
+    readonly props: ServiceInstancesProps;
+    /**
+     * Attribute ServiceInstanceIds: The list of service instance IDs.
+     */
+    readonly attrServiceInstanceIds: ros.IResolvable | string;
+    /**
+     * Attribute ServiceInstances: The list of service instances.
+     */
+    readonly attrServiceInstances: ros.IResolvable | string;
+}
 /**
  * This class encapsulates and extends the ROS resource type `DATASOURCE::ComputeNest::ServiceInstances`, which is used to query the information about service instances.
  * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosServiceInstances`for a more convenient development experience.
  * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstances
  */
-export declare class ServiceInstances extends ros.Resource {
+export declare class ServiceInstances extends ros.Resource implements IServiceInstances {
     protected scope: ros.Construct;
     protected id: string;
-    protected props: ServiceInstancesProps;
+    readonly props: ServiceInstancesProps;
     protected enableResourcePropertyConstraint: boolean;
     /**
      * Attribute ServiceInstanceIds: The list of service instance IDs.
      */
-    readonly attrServiceInstanceIds: ros.IResolvable;
+    readonly attrServiceInstanceIds: ros.IResolvable | string;
     /**
      * Attribute ServiceInstances: The list of service instances.
      */
-    readonly attrServiceInstances: ros.IResolvable;
+    readonly attrServiceInstances: ros.IResolvable | string;
     /**
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource

package/lib/datasource/serviceinstances.js

@@ -31,4 +31,4 @@ class ServiceInstances extends ros.Resource {
     }
 }
 exports.ServiceInstances = ServiceInstances;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/intranetconnectorendpoint.d.ts

@@ -39,20 +39,30 @@ export interface IntranetConnectorEndpointProps {
      */
     readonly type?: string | ros.IResolvable;
 }
+/**
+ * Represents a `IntranetConnectorEndpoint`.
+ */
+export interface IIntranetConnectorEndpoint extends ros.IResource {
+    readonly props: IntranetConnectorEndpointProps;
+    /**
+     * Attribute EndpointId: The ID of the endpoint.
+     */
+    readonly attrEndpointId: ros.IResolvable | string;
+}
 /**
  * This class encapsulates and extends the ROS resource type `ALIYUN::ComputeNest::IntranetConnectorEndpoint`, which is used to create an endpoint.
  * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosIntranetConnectorEndpoint`for a more convenient development experience.
  * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-computenest-intranetconnectorendpoint
  */
-export declare class IntranetConnectorEndpoint extends ros.Resource {
+export declare class IntranetConnectorEndpoint extends ros.Resource implements IIntranetConnectorEndpoint {
     protected scope: ros.Construct;
     protected id: string;
-    protected props: IntranetConnectorEndpointProps;
+    readonly props: IntranetConnectorEndpointProps;
     protected enableResourcePropertyConstraint: boolean;
     /**
      * Attribute EndpointId: The ID of the endpoint.
      */
-    readonly attrEndpointId: ros.IResolvable;
+    readonly attrEndpointId: ros.IResolvable | string;
     /**
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource

package/lib/intranetconnectorendpoint.js

@@ -35,4 +35,4 @@ class IntranetConnectorEndpoint extends ros.Resource {
     }
 }
 exports.IntranetConnectorEndpoint = IntranetConnectorEndpoint;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/serviceinstance.d.ts

@@ -69,108 +69,206 @@ export interface ServiceInstanceProps {
      */
     readonly templateName?: string | ros.IResolvable;
 }
+/**
+ * Represents a `ServiceInstance`.
+ */
+export interface IServiceInstance extends ros.IResource {
+    readonly props: ServiceInstanceProps;
+    /**
+     * Attribute Components: Additional billing items.
+     */
+    readonly attrComponents: ros.IResolvable | string;
+    /**
+     * Attribute CreateTime: Creation time.
+     */
+    readonly attrCreateTime: ros.IResolvable | string;
+    /**
+     * Attribute EnableInstanceOps: Whether the service instance has the O & M function.
+     */
+    readonly attrEnableInstanceOps: ros.IResolvable | string;
+    /**
+     * Attribute EnableUserPrometheus: Whether Prometheus monitoring is enabled.
+     */
+    readonly attrEnableUserPrometheus: ros.IResolvable | string;
+    /**
+     * Attribute IsOperated: Whether the generation O & M function of the service instance is enabled.
+     */
+    readonly attrIsOperated: ros.IResolvable | string;
+    /**
+     * Attribute LicenseEndTime: License expiration time.
+     */
+    readonly attrLicenseEndTime: ros.IResolvable | string;
+    /**
+     * Attribute Name: The name of the service instance.
+     */
+    readonly attrName: ros.IResolvable | string;
+    /**
+     * Attribute NetworkConfig: Network configuration information.
+     */
+    readonly attrNetworkConfig: ros.IResolvable | string;
+    /**
+     * Attribute Outputs: Create the output Field returned by the service instance.
+     */
+    readonly attrOutputs: ros.IResolvable | string;
+    /**
+     * Attribute Parameters: The parameters entered by the deployment service instance.
+     */
+    readonly attrParameters: ros.IResolvable | string;
+    /**
+     * Attribute PredefinedParameterName: Package name.
+     */
+    readonly attrPredefinedParameterName: ros.IResolvable | string;
+    /**
+     * Attribute Progress: The deployment progress of the service instance. Unit:%.
+     */
+    readonly attrProgress: ros.IResolvable | string;
+    /**
+     * Attribute ResourceGroupId: The ID of the resource group.
+     */
+    readonly attrResourceGroupId: ros.IResolvable | string;
+    /**
+     * Attribute Service: Service details.
+     */
+    readonly attrService: ros.IResolvable | string;
+    /**
+     * Attribute ServiceInstanceId: The ID of the service instance.
+     */
+    readonly attrServiceInstanceId: ros.IResolvable | string;
+    /**
+     * Attribute ServiceType: Service type.
+     */
+    readonly attrServiceType: ros.IResolvable | string;
+    /**
+     * Attribute Source: The source of the service instance.
+     */
+    readonly attrSource: ros.IResolvable | string;
+    /**
+     * Attribute StatusDetail: The status description of the deployment instance.
+     */
+    readonly attrStatusDetail: ros.IResolvable | string;
+    /**
+     * Attribute SupplierUid: Service provider AliUid.
+     */
+    readonly attrSupplierUid: ros.IResolvable | string;
+    /**
+     * Attribute Tags: User-defined labels.
+     */
+    readonly attrTags: ros.IResolvable | string;
+    /**
+     * Attribute TemplateName: Template name.
+     */
+    readonly attrTemplateName: ros.IResolvable | string;
+    /**
+     * Attribute UpdateTime: Update time.
+     */
+    readonly attrUpdateTime: ros.IResolvable | string;
+    /**
+     * Attribute UserId: AliUid of the user.
+     */
+    readonly attrUserId: ros.IResolvable | string;
+}
 /**
  * This class encapsulates and extends the ROS resource type `ALIYUN::ComputeNest::ServiceInstance`, which is used to create and deploy a service instance.
  * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosServiceInstance`for a more convenient development experience.
  * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-computenest-serviceinstance
  */
-export declare class ServiceInstance extends ros.Resource {
+export declare class ServiceInstance extends ros.Resource implements IServiceInstance {
     protected scope: ros.Construct;
     protected id: string;
-    protected props: ServiceInstanceProps;
+    readonly props: ServiceInstanceProps;
     protected enableResourcePropertyConstraint: boolean;
     /**
      * Attribute Components: Additional billing items.
      */
-    readonly attrComponents: ros.IResolvable;
+    readonly attrComponents: ros.IResolvable | string;
     /**
      * Attribute CreateTime: Creation time.
      */
-    readonly attrCreateTime: ros.IResolvable;
+    readonly attrCreateTime: ros.IResolvable | string;
     /**
      * Attribute EnableInstanceOps: Whether the service instance has the O & M function.
      */
-    readonly attrEnableInstanceOps: ros.IResolvable;
+    readonly attrEnableInstanceOps: ros.IResolvable | string;
     /**
      * Attribute EnableUserPrometheus: Whether Prometheus monitoring is enabled.
      */
-    readonly attrEnableUserPrometheus: ros.IResolvable;
+    readonly attrEnableUserPrometheus: ros.IResolvable | string;
     /**
      * Attribute IsOperated: Whether the generation O & M function of the service instance is enabled.
      */
-    readonly attrIsOperated: ros.IResolvable;
+    readonly attrIsOperated: ros.IResolvable | string;
     /**
      * Attribute LicenseEndTime: License expiration time.
      */
-    readonly attrLicenseEndTime: ros.IResolvable;
+    readonly attrLicenseEndTime: ros.IResolvable | string;
     /**
      * Attribute Name: The name of the service instance.
      */
-    readonly attrName: ros.IResolvable;
+    readonly attrName: ros.IResolvable | string;
     /**
      * Attribute NetworkConfig: Network configuration information.
      */
-    readonly attrNetworkConfig: ros.IResolvable;
+    readonly attrNetworkConfig: ros.IResolvable | string;
     /**
      * Attribute Outputs: Create the output Field returned by the service instance.
      */
-    readonly attrOutputs: ros.IResolvable;
+    readonly attrOutputs: ros.IResolvable | string;
     /**
      * Attribute Parameters: The parameters entered by the deployment service instance.
      */
-    readonly attrParameters: ros.IResolvable;
+    readonly attrParameters: ros.IResolvable | string;
     /**
      * Attribute PredefinedParameterName: Package name.
      */
-    readonly attrPredefinedParameterName: ros.IResolvable;
+    readonly attrPredefinedParameterName: ros.IResolvable | string;
     /**
      * Attribute Progress: The deployment progress of the service instance. Unit:%.
      */
-    readonly attrProgress: ros.IResolvable;
+    readonly attrProgress: ros.IResolvable | string;
     /**
      * Attribute ResourceGroupId: The ID of the resource group.
      */
-    readonly attrResourceGroupId: ros.IResolvable;
+    readonly attrResourceGroupId: ros.IResolvable | string;
     /**
      * Attribute Service: Service details.
      */
-    readonly attrService: ros.IResolvable;
+    readonly attrService: ros.IResolvable | string;
     /**
      * Attribute ServiceInstanceId: The ID of the service instance.
      */
-    readonly attrServiceInstanceId: ros.IResolvable;
+    readonly attrServiceInstanceId: ros.IResolvable | string;
     /**
      * Attribute ServiceType: Service type.
      */
-    readonly attrServiceType: ros.IResolvable;
+    readonly attrServiceType: ros.IResolvable | string;
     /**
      * Attribute Source: The source of the service instance.
      */
-    readonly attrSource: ros.IResolvable;
+    readonly attrSource: ros.IResolvable | string;
     /**
      * Attribute StatusDetail: The status description of the deployment instance.
      */
-    readonly attrStatusDetail: ros.IResolvable;
+    readonly attrStatusDetail: ros.IResolvable | string;
     /**
      * Attribute SupplierUid: Service provider AliUid.
      */
-    readonly attrSupplierUid: ros.IResolvable;
+    readonly attrSupplierUid: ros.IResolvable | string;
     /**
      * Attribute Tags: User-defined labels.
      */
-    readonly attrTags: ros.IResolvable;
+    readonly attrTags: ros.IResolvable | string;
     /**
      * Attribute TemplateName: Template name.
      */
-    readonly attrTemplateName: ros.IResolvable;
+    readonly attrTemplateName: ros.IResolvable | string;
     /**
      * Attribute UpdateTime: Update time.
      */
-    readonly attrUpdateTime: ros.IResolvable;
+    readonly attrUpdateTime: ros.IResolvable | string;
     /**
      * Attribute UserId: AliUid of the user.
      */
-    readonly attrUserId: ros.IResolvable;
+    readonly attrUserId: ros.IResolvable | string;
     /**
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource

package/lib/serviceinstance.js

@@ -64,4 +64,4 @@ class ServiceInstance extends ros.Resource {
     }
 }
 exports.ServiceInstance = ServiceInstance;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serviceinstance.js","sourceRoot":"","sources":["serviceinstance.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ros from '@alicloud/ros-cdk-core';\nimport { RosServiceInstance } from './computenest.generated';\n// Generated from the AliCloud ROS Resource Specification\nexport { RosServiceInstance as ServiceInstanceProperty };\n\n/**\n * Properties for defining a `ServiceInstance`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-computenest-serviceinstance\n */\nexport interface ServiceInstanceProps {\n\n    /**\n     * Property service: Service details.\n     */\n    readonly service: RosServiceInstance.ServiceProperty | ros.IResolvable;\n\n    /**\n     * Property commodity: Cloud market commodity purchase parameters.\n     */\n    readonly commodity?: RosServiceInstance.CommodityProperty | ros.IResolvable;\n\n    /**\n     * Property contactGroup: Alarm Contact Group.\n     */\n    readonly contactGroup?: string | ros.IResolvable;\n\n    /**\n     * Property enableInstanceOps: Whether the service instance has the O & M function. Possible values:\n     * - true: The service instance has a generation O & M function.\n     * - false: The service instance does not have the O & M function.\n     */\n    readonly enableInstanceOps?: boolean | ros.IResolvable;\n\n    /**\n     * Property enableUserPrometheus: Whether Prometheus monitoring is enabled. Possible values:\n     * - true: enabled.\n     * - false: not enabled.\n     */\n    readonly enableUserPrometheus?: boolean | ros.IResolvable;\n\n    /**\n     * Property marketInstanceId: The ID of the cloud marketplace instance.\n     */\n    readonly marketInstanceId?: string | ros.IResolvable;\n\n    /**\n     * Property name: The name of the service instance.\n     */\n    readonly name?: string | ros.IResolvable;\n\n    /**\n     * Property operationName: Change operation name.\n     */\n    readonly operationName?: string | ros.IResolvable;\n\n    /**\n     * Property parameters: The parameters entered by the deployment service instance.\n     */\n    readonly parameters?: { [key: string]: (any | ros.IResolvable) } | ros.IResolvable;\n\n    /**\n     * Property predefinedParameterName: Package name.\n     */\n    readonly predefinedParameterName?: string | ros.IResolvable;\n\n    /**\n     * Property resourceGroupId: The ID of the resource group.\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n\n    /**\n     * Property specificationCode: Commodity specification Code.\n     */\n    readonly specificationCode?: string | ros.IResolvable;\n\n    /**\n     * Property tags: Tags of service instance.\n     */\n    readonly tags?: RosServiceInstance.TagsProperty[];\n\n    /**\n     * Property templateName: Template name.\n     */\n    readonly templateName?: string | ros.IResolvable;\n}\n\n/**\n * This class encapsulates and extends the ROS resource type `ALIYUN::ComputeNest::ServiceInstance`, which is used to create and deploy a service instance.\n * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosServiceInstance`for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-computenest-serviceinstance\n */\nexport class ServiceInstance extends ros.Resource {\n    protected scope: ros.Construct;\n    protected id: string;\n    protected props: ServiceInstanceProps;\n    protected enableResourcePropertyConstraint: boolean;\n\n    /**\n     * Attribute Components: Additional billing items.\n     */\n    public readonly attrComponents: ros.IResolvable;\n\n    /**\n     * Attribute CreateTime: Creation time.\n     */\n    public readonly attrCreateTime: ros.IResolvable;\n\n    /**\n     * Attribute EnableInstanceOps: Whether the service instance has the O & M function.\n     */\n    public readonly attrEnableInstanceOps: ros.IResolvable;\n\n    /**\n     * Attribute EnableUserPrometheus: Whether Prometheus monitoring is enabled.\n     */\n    public readonly attrEnableUserPrometheus: ros.IResolvable;\n\n    /**\n     * Attribute IsOperated: Whether the generation O & M function of the service instance is enabled.\n     */\n    public readonly attrIsOperated: ros.IResolvable;\n\n    /**\n     * Attribute LicenseEndTime: License expiration time.\n     */\n    public readonly attrLicenseEndTime: ros.IResolvable;\n\n    /**\n     * Attribute Name: The name of the service instance.\n     */\n    public readonly attrName: ros.IResolvable;\n\n    /**\n     * Attribute NetworkConfig: Network configuration information.\n     */\n    public readonly attrNetworkConfig: ros.IResolvable;\n\n    /**\n     * Attribute Outputs: Create the output Field returned by the service instance.\n     */\n    public readonly attrOutputs: ros.IResolvable;\n\n    /**\n     * Attribute Parameters: The parameters entered by the deployment service instance.\n     */\n    public readonly attrParameters: ros.IResolvable;\n\n    /**\n     * Attribute PredefinedParameterName: Package name.\n     */\n    public readonly attrPredefinedParameterName: ros.IResolvable;\n\n    /**\n     * Attribute Progress: The deployment progress of the service instance. Unit:%.\n     */\n    public readonly attrProgress: ros.IResolvable;\n\n    /**\n     * Attribute ResourceGroupId: The ID of the resource group.\n     */\n    public readonly attrResourceGroupId: ros.IResolvable;\n\n    /**\n     * Attribute Service: Service details.\n     */\n    public readonly attrService: ros.IResolvable;\n\n    /**\n     * Attribute ServiceInstanceId: The ID of the service instance.\n     */\n    public readonly attrServiceInstanceId: ros.IResolvable;\n\n    /**\n     * Attribute ServiceType: Service type.\n     */\n    public readonly attrServiceType: ros.IResolvable;\n\n    /**\n     * Attribute Source: The source of the service instance.\n     */\n    public readonly attrSource: ros.IResolvable;\n\n    /**\n     * Attribute StatusDetail: The status description of the deployment instance.\n     */\n    public readonly attrStatusDetail: ros.IResolvable;\n\n    /**\n     * Attribute SupplierUid: Service provider AliUid.\n     */\n    public readonly attrSupplierUid: ros.IResolvable;\n\n    /**\n     * Attribute Tags: User-defined labels.\n     */\n    public readonly attrTags: ros.IResolvable;\n\n    /**\n     * Attribute TemplateName: Template name.\n     */\n    public readonly attrTemplateName: ros.IResolvable;\n\n    /**\n     * Attribute UpdateTime: Update time.\n     */\n    public readonly attrUpdateTime: ros.IResolvable;\n\n    /**\n     * Attribute UserId: AliUid of the user.\n     */\n    public readonly attrUserId: 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: ServiceInstanceProps, 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 rosServiceInstance = new RosServiceInstance(this, id,  {\n            specificationCode: props.specificationCode,\n            parameters: props.parameters,\n            resourceGroupId: props.resourceGroupId,\n            operationName: props.operationName,\n            enableInstanceOps: props.enableInstanceOps,\n            service: props.service,\n            predefinedParameterName: props.predefinedParameterName,\n            name: props.name,\n            commodity: props.commodity,\n            enableUserPrometheus: props.enableUserPrometheus,\n            templateName: props.templateName,\n            marketInstanceId: props.marketInstanceId,\n            contactGroup: props.contactGroup,\n            tags: props.tags,\n        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);\n        this.resource = rosServiceInstance;\n        this.attrComponents = rosServiceInstance.attrComponents;\n        this.attrCreateTime = rosServiceInstance.attrCreateTime;\n        this.attrEnableInstanceOps = rosServiceInstance.attrEnableInstanceOps;\n        this.attrEnableUserPrometheus = rosServiceInstance.attrEnableUserPrometheus;\n        this.attrIsOperated = rosServiceInstance.attrIsOperated;\n        this.attrLicenseEndTime = rosServiceInstance.attrLicenseEndTime;\n        this.attrName = rosServiceInstance.attrName;\n        this.attrNetworkConfig = rosServiceInstance.attrNetworkConfig;\n        this.attrOutputs = rosServiceInstance.attrOutputs;\n        this.attrParameters = rosServiceInstance.attrParameters;\n        this.attrPredefinedParameterName = rosServiceInstance.attrPredefinedParameterName;\n        this.attrProgress = rosServiceInstance.attrProgress;\n        this.attrResourceGroupId = rosServiceInstance.attrResourceGroupId;\n        this.attrService = rosServiceInstance.attrService;\n        this.attrServiceInstanceId = rosServiceInstance.attrServiceInstanceId;\n        this.attrServiceType = rosServiceInstance.attrServiceType;\n        this.attrSource = rosServiceInstance.attrSource;\n        this.attrStatusDetail = rosServiceInstance.attrStatusDetail;\n        this.attrSupplierUid = rosServiceInstance.attrSupplierUid;\n        this.attrTags = rosServiceInstance.attrTags;\n        this.attrTemplateName = rosServiceInstance.attrTemplateName;\n        this.attrUpdateTime = rosServiceInstance.attrUpdateTime;\n        this.attrUserId = rosServiceInstance.attrUserId;\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serviceinstance.js","sourceRoot":"","sources":["serviceinstance.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ros from '@alicloud/ros-cdk-core';\nimport { RosServiceInstance } from './computenest.generated';\n// Generated from the AliCloud ROS Resource Specification\nexport { RosServiceInstance as ServiceInstanceProperty };\n\n/**\n * Properties for defining a `ServiceInstance`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-computenest-serviceinstance\n */\nexport interface ServiceInstanceProps {\n\n    /**\n     * Property service: Service details.\n     */\n    readonly service: RosServiceInstance.ServiceProperty | ros.IResolvable;\n\n    /**\n     * Property commodity: Cloud market commodity purchase parameters.\n     */\n    readonly commodity?: RosServiceInstance.CommodityProperty | ros.IResolvable;\n\n    /**\n     * Property contactGroup: Alarm Contact Group.\n     */\n    readonly contactGroup?: string | ros.IResolvable;\n\n    /**\n     * Property enableInstanceOps: Whether the service instance has the O & M function. Possible values:\n     * - true: The service instance has a generation O & M function.\n     * - false: The service instance does not have the O & M function.\n     */\n    readonly enableInstanceOps?: boolean | ros.IResolvable;\n\n    /**\n     * Property enableUserPrometheus: Whether Prometheus monitoring is enabled. Possible values:\n     * - true: enabled.\n     * - false: not enabled.\n     */\n    readonly enableUserPrometheus?: boolean | ros.IResolvable;\n\n    /**\n     * Property marketInstanceId: The ID of the cloud marketplace instance.\n     */\n    readonly marketInstanceId?: string | ros.IResolvable;\n\n    /**\n     * Property name: The name of the service instance.\n     */\n    readonly name?: string | ros.IResolvable;\n\n    /**\n     * Property operationName: Change operation name.\n     */\n    readonly operationName?: string | ros.IResolvable;\n\n    /**\n     * Property parameters: The parameters entered by the deployment service instance.\n     */\n    readonly parameters?: { [key: string]: (any | ros.IResolvable) } | ros.IResolvable;\n\n    /**\n     * Property predefinedParameterName: Package name.\n     */\n    readonly predefinedParameterName?: string | ros.IResolvable;\n\n    /**\n     * Property resourceGroupId: The ID of the resource group.\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n\n    /**\n     * Property specificationCode: Commodity specification Code.\n     */\n    readonly specificationCode?: string | ros.IResolvable;\n\n    /**\n     * Property tags: Tags of service instance.\n     */\n    readonly tags?: RosServiceInstance.TagsProperty[];\n\n    /**\n     * Property templateName: Template name.\n     */\n    readonly templateName?: string | ros.IResolvable;\n}\n\n/**\n * Represents a `ServiceInstance`.\n */\nexport interface IServiceInstance extends ros.IResource {\n    readonly props: ServiceInstanceProps;\n\n    /**\n     * Attribute Components: Additional billing items.\n     */\n    readonly attrComponents: ros.IResolvable | string;\n\n    /**\n     * Attribute CreateTime: Creation time.\n     */\n    readonly attrCreateTime: ros.IResolvable | string;\n\n    /**\n     * Attribute EnableInstanceOps: Whether the service instance has the O & M function.\n     */\n    readonly attrEnableInstanceOps: ros.IResolvable | string;\n\n    /**\n     * Attribute EnableUserPrometheus: Whether Prometheus monitoring is enabled.\n     */\n    readonly attrEnableUserPrometheus: ros.IResolvable | string;\n\n    /**\n     * Attribute IsOperated: Whether the generation O & M function of the service instance is enabled.\n     */\n    readonly attrIsOperated: ros.IResolvable | string;\n\n    /**\n     * Attribute LicenseEndTime: License expiration time.\n     */\n    readonly attrLicenseEndTime: ros.IResolvable | string;\n\n    /**\n     * Attribute Name: The name of the service instance.\n     */\n    readonly attrName: ros.IResolvable | string;\n\n    /**\n     * Attribute NetworkConfig: Network configuration information.\n     */\n    readonly attrNetworkConfig: ros.IResolvable | string;\n\n    /**\n     * Attribute Outputs: Create the output Field returned by the service instance.\n     */\n    readonly attrOutputs: ros.IResolvable | string;\n\n    /**\n     * Attribute Parameters: The parameters entered by the deployment service instance.\n     */\n    readonly attrParameters: ros.IResolvable | string;\n\n    /**\n     * Attribute PredefinedParameterName: Package name.\n     */\n    readonly attrPredefinedParameterName: ros.IResolvable | string;\n\n    /**\n     * Attribute Progress: The deployment progress of the service instance. Unit:%.\n     */\n    readonly attrProgress: ros.IResolvable | string;\n\n    /**\n     * Attribute ResourceGroupId: The ID of the resource group.\n     */\n    readonly attrResourceGroupId: ros.IResolvable | string;\n\n    /**\n     * Attribute Service: Service details.\n     */\n    readonly attrService: ros.IResolvable | string;\n\n    /**\n     * Attribute ServiceInstanceId: The ID of the service instance.\n     */\n    readonly attrServiceInstanceId: ros.IResolvable | string;\n\n    /**\n     * Attribute ServiceType: Service type.\n     */\n    readonly attrServiceType: ros.IResolvable | string;\n\n    /**\n     * Attribute Source: The source of the service instance.\n     */\n    readonly attrSource: ros.IResolvable | string;\n\n    /**\n     * Attribute StatusDetail: The status description of the deployment instance.\n     */\n    readonly attrStatusDetail: ros.IResolvable | string;\n\n    /**\n     * Attribute SupplierUid: Service provider AliUid.\n     */\n    readonly attrSupplierUid: ros.IResolvable | string;\n\n    /**\n     * Attribute Tags: User-defined labels.\n     */\n    readonly attrTags: ros.IResolvable | string;\n\n    /**\n     * Attribute TemplateName: Template name.\n     */\n    readonly attrTemplateName: ros.IResolvable | string;\n\n    /**\n     * Attribute UpdateTime: Update time.\n     */\n    readonly attrUpdateTime: ros.IResolvable | string;\n\n    /**\n     * Attribute UserId: AliUid of the user.\n     */\n    readonly attrUserId: ros.IResolvable | string;\n}\n/**\n * This class encapsulates and extends the ROS resource type `ALIYUN::ComputeNest::ServiceInstance`, which is used to create and deploy a service instance.\n * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosServiceInstance`for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-computenest-serviceinstance\n */\nexport class ServiceInstance extends ros.Resource implements IServiceInstance {\n    protected scope: ros.Construct;\n    protected id: string;\n    public readonly props: ServiceInstanceProps;\n    protected enableResourcePropertyConstraint: boolean;\n\n    /**\n     * Attribute Components: Additional billing items.\n     */\n    public readonly attrComponents: ros.IResolvable | string;\n\n    /**\n     * Attribute CreateTime: Creation time.\n     */\n    public readonly attrCreateTime: ros.IResolvable | string;\n\n    /**\n     * Attribute EnableInstanceOps: Whether the service instance has the O & M function.\n     */\n    public readonly attrEnableInstanceOps: ros.IResolvable | string;\n\n    /**\n     * Attribute EnableUserPrometheus: Whether Prometheus monitoring is enabled.\n     */\n    public readonly attrEnableUserPrometheus: ros.IResolvable | string;\n\n    /**\n     * Attribute IsOperated: Whether the generation O & M function of the service instance is enabled.\n     */\n    public readonly attrIsOperated: ros.IResolvable | string;\n\n    /**\n     * Attribute LicenseEndTime: License expiration time.\n     */\n    public readonly attrLicenseEndTime: ros.IResolvable | string;\n\n    /**\n     * Attribute Name: The name of the service instance.\n     */\n    public readonly attrName: ros.IResolvable | string;\n\n    /**\n     * Attribute NetworkConfig: Network configuration information.\n     */\n    public readonly attrNetworkConfig: ros.IResolvable | string;\n\n    /**\n     * Attribute Outputs: Create the output Field returned by the service instance.\n     */\n    public readonly attrOutputs: ros.IResolvable | string;\n\n    /**\n     * Attribute Parameters: The parameters entered by the deployment service instance.\n     */\n    public readonly attrParameters: ros.IResolvable | string;\n\n    /**\n     * Attribute PredefinedParameterName: Package name.\n     */\n    public readonly attrPredefinedParameterName: ros.IResolvable | string;\n\n    /**\n     * Attribute Progress: The deployment progress of the service instance. Unit:%.\n     */\n    public readonly attrProgress: ros.IResolvable | string;\n\n    /**\n     * Attribute ResourceGroupId: The ID of the resource group.\n     */\n    public readonly attrResourceGroupId: ros.IResolvable | string;\n\n    /**\n     * Attribute Service: Service details.\n     */\n    public readonly attrService: ros.IResolvable | string;\n\n    /**\n     * Attribute ServiceInstanceId: The ID of the service instance.\n     */\n    public readonly attrServiceInstanceId: ros.IResolvable | string;\n\n    /**\n     * Attribute ServiceType: Service type.\n     */\n    public readonly attrServiceType: ros.IResolvable | string;\n\n    /**\n     * Attribute Source: The source of the service instance.\n     */\n    public readonly attrSource: ros.IResolvable | string;\n\n    /**\n     * Attribute StatusDetail: The status description of the deployment instance.\n     */\n    public readonly attrStatusDetail: ros.IResolvable | string;\n\n    /**\n     * Attribute SupplierUid: Service provider AliUid.\n     */\n    public readonly attrSupplierUid: ros.IResolvable | string;\n\n    /**\n     * Attribute Tags: User-defined labels.\n     */\n    public readonly attrTags: ros.IResolvable | string;\n\n    /**\n     * Attribute TemplateName: Template name.\n     */\n    public readonly attrTemplateName: ros.IResolvable | string;\n\n    /**\n     * Attribute UpdateTime: Update time.\n     */\n    public readonly attrUpdateTime: ros.IResolvable | string;\n\n    /**\n     * Attribute UserId: AliUid of the user.\n     */\n    public readonly attrUserId: ros.IResolvable | string;\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: ServiceInstanceProps, 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 rosServiceInstance = new RosServiceInstance(this, id,  {\n            specificationCode: props.specificationCode,\n            parameters: props.parameters,\n            resourceGroupId: props.resourceGroupId,\n            operationName: props.operationName,\n            enableInstanceOps: props.enableInstanceOps,\n            service: props.service,\n            predefinedParameterName: props.predefinedParameterName,\n            name: props.name,\n            commodity: props.commodity,\n            enableUserPrometheus: props.enableUserPrometheus,\n            templateName: props.templateName,\n            marketInstanceId: props.marketInstanceId,\n            contactGroup: props.contactGroup,\n            tags: props.tags,\n        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);\n        this.resource = rosServiceInstance;\n        this.attrComponents = rosServiceInstance.attrComponents;\n        this.attrCreateTime = rosServiceInstance.attrCreateTime;\n        this.attrEnableInstanceOps = rosServiceInstance.attrEnableInstanceOps;\n        this.attrEnableUserPrometheus = rosServiceInstance.attrEnableUserPrometheus;\n        this.attrIsOperated = rosServiceInstance.attrIsOperated;\n        this.attrLicenseEndTime = rosServiceInstance.attrLicenseEndTime;\n        this.attrName = rosServiceInstance.attrName;\n        this.attrNetworkConfig = rosServiceInstance.attrNetworkConfig;\n        this.attrOutputs = rosServiceInstance.attrOutputs;\n        this.attrParameters = rosServiceInstance.attrParameters;\n        this.attrPredefinedParameterName = rosServiceInstance.attrPredefinedParameterName;\n        this.attrProgress = rosServiceInstance.attrProgress;\n        this.attrResourceGroupId = rosServiceInstance.attrResourceGroupId;\n        this.attrService = rosServiceInstance.attrService;\n        this.attrServiceInstanceId = rosServiceInstance.attrServiceInstanceId;\n        this.attrServiceType = rosServiceInstance.attrServiceType;\n        this.attrSource = rosServiceInstance.attrSource;\n        this.attrStatusDetail = rosServiceInstance.attrStatusDetail;\n        this.attrSupplierUid = rosServiceInstance.attrSupplierUid;\n        this.attrTags = rosServiceInstance.attrTags;\n        this.attrTemplateName = rosServiceInstance.attrTemplateName;\n        this.attrUpdateTime = rosServiceInstance.attrUpdateTime;\n        this.attrUserId = rosServiceInstance.attrUserId;\n    }\n}\n"]}

package/package.json

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