@alicloud/ros-cdk-computenest 1.4.0 → 1.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/lib/datasource/computenest.generated.d.ts +150 -0
  2. package/lib/datasource/computenest.generated.js +101 -2
  3. package/lib/datasource/index.d.ts +1 -0
  4. package/lib/datasource/index.js +2 -1
  5. package/lib/datasource/serviceinstance.d.ts +133 -0
  6. package/lib/datasource/serviceinstance.js +56 -0
  7. package/package.json +1 -1
package/lib/datasource/computenest.generated.d.ts CHANGED
@@ -1,4 +1,154 @@
1
1
  import * as ros from '@alicloud/ros-cdk-core';
2
+ /**
3
+ * Properties for defining a `RosServiceInstance`.
4
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance
5
+ */
6
+ export interface RosServiceInstanceProps {
7
+ /**
8
+ * @Property serviceInstanceId: The ID of the service instance.
9
+ */
10
+ readonly serviceInstanceId: string | ros.IResolvable;
11
+ /**
12
+ * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:
13
+ * - Never: Never refresh the datasource resource when the stack is updated.
14
+ * - Always: Always refresh the datasource resource when the stack is updated.
15
+ * Default is Never.
16
+ */
17
+ readonly refreshOptions?: string | ros.IResolvable;
18
+ }
19
+ /**
20
+ * This class is a base encapsulation around the ROS resource type `DATASOURCE::ComputeNest::ServiceInstance`.
21
+ * @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.
22
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance
23
+ */
24
+ export declare class RosServiceInstance extends ros.RosResource {
25
+ /**
26
+ * The resource type name for this resource class.
27
+ */
28
+ static readonly ROS_RESOURCE_TYPE_NAME = "DATASOURCE::ComputeNest::ServiceInstance";
29
+ /**
30
+ * @Attribute Components: Cloud Marketplace additional billing items.
31
+ */
32
+ readonly attrComponents: ros.IResolvable;
33
+ /**
34
+ * @Attribute CreateTime: The time when the serviceInstance was created.
35
+ */
36
+ readonly attrCreateTime: ros.IResolvable;
37
+ /**
38
+ * @Attribute EnableInstanceOps: Indicates whether the service instance supports the operation feature.
39
+ */
40
+ readonly attrEnableInstanceOps: ros.IResolvable;
41
+ /**
42
+ * @Attribute EnableUserPrometheus: Whether to enable Prometheus monitoring.
43
+ */
44
+ readonly attrEnableUserPrometheus: ros.IResolvable;
45
+ /**
46
+ * @Attribute IsOperated: Indicates whether the hosted O&M feature is enabled for the service instance.
47
+ */
48
+ readonly attrIsOperated: ros.IResolvable;
49
+ /**
50
+ * @Attribute LicenseEndTime: The expiration time of licence.
51
+ */
52
+ readonly attrLicenseEndTime: ros.IResolvable;
53
+ /**
54
+ * @Attribute MarketInstanceId: The ID of the cloud marketplace instance.
55
+ */
56
+ readonly attrMarketInstanceId: ros.IResolvable;
57
+ /**
58
+ * @Attribute NetworkConfig: The network configurations.
59
+ */
60
+ readonly attrNetworkConfig: ros.IResolvable;
61
+ /**
62
+ * @Attribute Outputs: The outputs returned from creating the service instance.
63
+ */
64
+ readonly attrOutputs: ros.IResolvable;
65
+ /**
66
+ * @Attribute Parameters: The parameters configured for the service instance.
67
+ */
68
+ readonly attrParameters: ros.IResolvable;
69
+ /**
70
+ * @Attribute PredefinedParameterName: The name of the package .
71
+ */
72
+ readonly attrPredefinedParameterName: ros.IResolvable;
73
+ /**
74
+ * @Attribute Progress: The deployment progress of the service instance. Unit: percentage.
75
+ */
76
+ readonly attrProgress: ros.IResolvable;
77
+ /**
78
+ * @Attribute ResourceGroupId: The resource group ID.
79
+ */
80
+ readonly attrResourceGroupId: ros.IResolvable;
81
+ /**
82
+ * @Attribute Service: The information about the service to which the service instance belongs.
83
+ */
84
+ readonly attrService: ros.IResolvable;
85
+ /**
86
+ * @Attribute ServiceInstanceId: The ID of the service instance.
87
+ */
88
+ readonly attrServiceInstanceId: ros.IResolvable;
89
+ /**
90
+ * @Attribute ServiceInstanceName: The name of the resource.
91
+ */
92
+ readonly attrServiceInstanceName: ros.IResolvable;
93
+ /**
94
+ * @Attribute ServiceType: The type of the service.
95
+ */
96
+ readonly attrServiceType: ros.IResolvable;
97
+ /**
98
+ * @Attribute Source: The source of the service instance.
99
+ */
100
+ readonly attrSource: ros.IResolvable;
101
+ /**
102
+ * @Attribute StatusDetail: The description of the deployment state of the service instance.
103
+ */
104
+ readonly attrStatusDetail: ros.IResolvable;
105
+ /**
106
+ * @Attribute SupplierUid: The Alibaba Cloud account ID of the service provider.
107
+ */
108
+ readonly attrSupplierUid: ros.IResolvable;
109
+ /**
110
+ * @Attribute Tags: The tags of the service instance.
111
+ */
112
+ readonly attrTags: ros.IResolvable;
113
+ /**
114
+ * @Attribute TemplateName: The name of the template.
115
+ */
116
+ readonly attrTemplateName: ros.IResolvable;
117
+ /**
118
+ * @Attribute UpdateTime: The time when the serviceInstance was last updated.
119
+ */
120
+ readonly attrUpdateTime: ros.IResolvable;
121
+ /**
122
+ * @Attribute UserId: The AliUid of the user.
123
+ */
124
+ readonly attrUserId: ros.IResolvable;
125
+ enableResourcePropertyConstraint: boolean;
126
+ /**
127
+ * @Property serviceInstanceId: The ID of the service instance.
128
+ */
129
+ serviceInstanceId: string | ros.IResolvable;
130
+ /**
131
+ * @Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:
132
+ * - Never: Never refresh the datasource resource when the stack is updated.
133
+ * - Always: Always refresh the datasource resource when the stack is updated.
134
+ * Default is Never.
135
+ */
136
+ refreshOptions: string | ros.IResolvable | undefined;
137
+ /**
138
+ * @param scope - scope in which this resource is defined
139
+ * @param id - scoped id of the resource
140
+ * @param props - resource properties
141
+ */
142
+ constructor(scope: ros.Construct, id: string, props: RosServiceInstanceProps, enableResourcePropertyConstraint: boolean);
143
+ protected get rosProperties(): {
144
+ [key: string]: any;
145
+ };
146
+ protected renderProperties(props: {
147
+ [key: string]: any;
148
+ }): {
149
+ [key: string]: any;
150
+ };
151
+ }
2
152
  /**
3
153
  * Properties for defining a `RosServiceInstances`.
4
154
  * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstances
package/lib/datasource/computenest.generated.js CHANGED
@@ -1,8 +1,107 @@
1
1
  "use strict";
2
2
  // Generated from the AliCloud ROS Resource Specification
3
3
  Object.defineProperty(exports, "__esModule", { value: true });
4
- exports.RosServiceInstances = void 0;
4
+ exports.RosServiceInstances = exports.RosServiceInstance = void 0;
5
5
  const ros = require("@alicloud/ros-cdk-core");
6
+ /**
7
+ * Determine whether the given properties match those of a `RosServiceInstanceProps`
8
+ *
9
+ * @param properties - the TypeScript properties of a `RosServiceInstanceProps`
10
+ *
11
+ * @returns the result of the validation.
12
+ */
13
+ function RosServiceInstancePropsValidator(properties) {
14
+ if (!ros.canInspect(properties)) {
15
+ return ros.VALIDATION_SUCCESS;
16
+ }
17
+ const errors = new ros.ValidationResults();
18
+ errors.collect(ros.propertyValidator('serviceInstanceId', ros.requiredValidator)(properties.serviceInstanceId));
19
+ errors.collect(ros.propertyValidator('serviceInstanceId', ros.validateString)(properties.serviceInstanceId));
20
+ if (properties.refreshOptions && (typeof properties.refreshOptions) !== 'object') {
21
+ errors.collect(ros.propertyValidator('refreshOptions', ros.validateAllowedValues)({
22
+ data: properties.refreshOptions,
23
+ allowedValues: ["Always", "Never"],
24
+ }));
25
+ }
26
+ errors.collect(ros.propertyValidator('refreshOptions', ros.validateString)(properties.refreshOptions));
27
+ return errors.wrap('supplied properties not correct for "RosServiceInstanceProps"');
28
+ }
29
+ /**
30
+ * Renders the AliCloud ROS Resource properties of an `DATASOURCE::ComputeNest::ServiceInstance` resource
31
+ *
32
+ * @param properties - the TypeScript properties of a `RosServiceInstanceProps`
33
+ *
34
+ * @returns the AliCloud ROS Resource properties of an `DATASOURCE::ComputeNest::ServiceInstance` resource.
35
+ */
36
+ // @ts-ignore TS6133
37
+ function rosServiceInstancePropsToRosTemplate(properties, enableResourcePropertyConstraint) {
38
+ if (!ros.canInspect(properties)) {
39
+ return properties;
40
+ }
41
+ if (enableResourcePropertyConstraint) {
42
+ RosServiceInstancePropsValidator(properties).assertSuccess();
43
+ }
44
+ return {
45
+ 'ServiceInstanceId': ros.stringToRosTemplate(properties.serviceInstanceId),
46
+ 'RefreshOptions': ros.stringToRosTemplate(properties.refreshOptions),
47
+ };
48
+ }
49
+ /**
50
+ * This class is a base encapsulation around the ROS resource type `DATASOURCE::ComputeNest::ServiceInstance`.
51
+ * @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.
52
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance
53
+ */
54
+ class RosServiceInstance extends ros.RosResource {
55
+ /**
56
+ * @param scope - scope in which this resource is defined
57
+ * @param id - scoped id of the resource
58
+ * @param props - resource properties
59
+ */
60
+ constructor(scope, id, props, enableResourcePropertyConstraint) {
61
+ super(scope, id, { type: RosServiceInstance.ROS_RESOURCE_TYPE_NAME, properties: props });
62
+ this.attrComponents = this.getAtt('Components');
63
+ this.attrCreateTime = this.getAtt('CreateTime');
64
+ this.attrEnableInstanceOps = this.getAtt('EnableInstanceOps');
65
+ this.attrEnableUserPrometheus = this.getAtt('EnableUserPrometheus');
66
+ this.attrIsOperated = this.getAtt('IsOperated');
67
+ this.attrLicenseEndTime = this.getAtt('LicenseEndTime');
68
+ this.attrMarketInstanceId = this.getAtt('MarketInstanceId');
69
+ this.attrNetworkConfig = this.getAtt('NetworkConfig');
70
+ this.attrOutputs = this.getAtt('Outputs');
71
+ this.attrParameters = this.getAtt('Parameters');
72
+ this.attrPredefinedParameterName = this.getAtt('PredefinedParameterName');
73
+ this.attrProgress = this.getAtt('Progress');
74
+ this.attrResourceGroupId = this.getAtt('ResourceGroupId');
75
+ this.attrService = this.getAtt('Service');
76
+ this.attrServiceInstanceId = this.getAtt('ServiceInstanceId');
77
+ this.attrServiceInstanceName = this.getAtt('ServiceInstanceName');
78
+ this.attrServiceType = this.getAtt('ServiceType');
79
+ this.attrSource = this.getAtt('Source');
80
+ this.attrStatusDetail = this.getAtt('StatusDetail');
81
+ this.attrSupplierUid = this.getAtt('SupplierUid');
82
+ this.attrTags = this.getAtt('Tags');
83
+ this.attrTemplateName = this.getAtt('TemplateName');
84
+ this.attrUpdateTime = this.getAtt('UpdateTime');
85
+ this.attrUserId = this.getAtt('UserId');
86
+ this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
87
+ this.serviceInstanceId = props.serviceInstanceId;
88
+ this.refreshOptions = props.refreshOptions;
89
+ }
90
+ get rosProperties() {
91
+ return {
92
+ serviceInstanceId: this.serviceInstanceId,
93
+ refreshOptions: this.refreshOptions,
94
+ };
95
+ }
96
+ renderProperties(props) {
97
+ return rosServiceInstancePropsToRosTemplate(props, this.enableResourcePropertyConstraint);
98
+ }
99
+ }
100
+ exports.RosServiceInstance = RosServiceInstance;
101
+ /**
102
+ * The resource type name for this resource class.
103
+ */
104
+ RosServiceInstance.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::ComputeNest::ServiceInstance";
6
105
  /**
7
106
  * Determine whether the given properties match those of a `RosServiceInstancesProps`
8
107
  *
@@ -79,4 +178,4 @@ exports.RosServiceInstances = RosServiceInstances;
79
178
  * The resource type name for this resource class.
80
179
  */
81
180
  RosServiceInstances.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::ComputeNest::ServiceInstances";
82
- //# 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"]}
181
+ //# 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 CHANGED
@@ -1,2 +1,3 @@
1
+ export * from './serviceinstance';
1
2
  export * from './serviceinstances';
2
3
  export * from './computenest.generated';
package/lib/datasource/index.js CHANGED
@@ -10,7 +10,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
10
10
  for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
11
11
  };
12
12
  Object.defineProperty(exports, "__esModule", { value: true });
13
+ __exportStar(require("./serviceinstance"), exports);
13
14
  __exportStar(require("./serviceinstances"), exports);
14
15
  // DATASOURCE::ComputeNest Resources:
15
16
  __exportStar(require("./computenest.generated"), exports);
16
- //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSxxREFBbUM7QUFFbkMscUNBQXFDO0FBQ3JDLDBEQUF3QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2VydmljZWluc3RhbmNlcyc7XG5cbi8vIERBVEFTT1VSQ0U6OkNvbXB1dGVOZXN0IFJlc291cmNlczpcbmV4cG9ydCAqIGZyb20gJy4vY29tcHV0ZW5lc3QuZ2VuZXJhdGVkJztcbiJdfQ==
17
+ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSxvREFBa0M7QUFDbEMscURBQW1DO0FBRW5DLHFDQUFxQztBQUNyQywwREFBd0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NlcnZpY2VpbnN0YW5jZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VpbnN0YW5jZXMnO1xuXG4vLyBEQVRBU09VUkNFOjpDb21wdXRlTmVzdCBSZXNvdXJjZXM6XG5leHBvcnQgKiBmcm9tICcuL2NvbXB1dGVuZXN0LmdlbmVyYXRlZCc7XG4iXX0=
package/lib/datasource/serviceinstance.d.ts ADDED
@@ -0,0 +1,133 @@
1
+ import * as ros from '@alicloud/ros-cdk-core';
2
+ import { RosServiceInstance } from './computenest.generated';
3
+ export { RosServiceInstance as ServiceInstanceProperty };
4
+ /**
5
+ * Properties for defining a `ServiceInstance`.
6
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance
7
+ */
8
+ export interface ServiceInstanceProps {
9
+ /**
10
+ * Property serviceInstanceId: The ID of the service instance.
11
+ */
12
+ readonly serviceInstanceId: string | ros.IResolvable;
13
+ /**
14
+ * Property refreshOptions: The refresh strategy for the datasource resource when the stack is updated. Valid values:
15
+ * - Never: Never refresh the datasource resource when the stack is updated.
16
+ * - Always: Always refresh the datasource resource when the stack is updated.
17
+ * Default is Never.
18
+ */
19
+ readonly refreshOptions?: string | ros.IResolvable;
20
+ }
21
+ /**
22
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::ComputeNest::ServiceInstance`.
23
+ * @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.
24
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance
25
+ */
26
+ export declare class ServiceInstance extends ros.Resource {
27
+ protected scope: ros.Construct;
28
+ protected id: string;
29
+ protected props: ServiceInstanceProps;
30
+ protected enableResourcePropertyConstraint: boolean;
31
+ /**
32
+ * Attribute Components: Cloud Marketplace additional billing items.
33
+ */
34
+ readonly attrComponents: ros.IResolvable;
35
+ /**
36
+ * Attribute CreateTime: The time when the serviceInstance was created.
37
+ */
38
+ readonly attrCreateTime: ros.IResolvable;
39
+ /**
40
+ * Attribute EnableInstanceOps: Indicates whether the service instance supports the operation feature.
41
+ */
42
+ readonly attrEnableInstanceOps: ros.IResolvable;
43
+ /**
44
+ * Attribute EnableUserPrometheus: Whether to enable Prometheus monitoring.
45
+ */
46
+ readonly attrEnableUserPrometheus: ros.IResolvable;
47
+ /**
48
+ * Attribute IsOperated: Indicates whether the hosted O&M feature is enabled for the service instance.
49
+ */
50
+ readonly attrIsOperated: ros.IResolvable;
51
+ /**
52
+ * Attribute LicenseEndTime: The expiration time of licence.
53
+ */
54
+ readonly attrLicenseEndTime: ros.IResolvable;
55
+ /**
56
+ * Attribute MarketInstanceId: The ID of the cloud marketplace instance.
57
+ */
58
+ readonly attrMarketInstanceId: ros.IResolvable;
59
+ /**
60
+ * Attribute NetworkConfig: The network configurations.
61
+ */
62
+ readonly attrNetworkConfig: ros.IResolvable;
63
+ /**
64
+ * Attribute Outputs: The outputs returned from creating the service instance.
65
+ */
66
+ readonly attrOutputs: ros.IResolvable;
67
+ /**
68
+ * Attribute Parameters: The parameters configured for the service instance.
69
+ */
70
+ readonly attrParameters: ros.IResolvable;
71
+ /**
72
+ * Attribute PredefinedParameterName: The name of the package .
73
+ */
74
+ readonly attrPredefinedParameterName: ros.IResolvable;
75
+ /**
76
+ * Attribute Progress: The deployment progress of the service instance. Unit: percentage.
77
+ */
78
+ readonly attrProgress: ros.IResolvable;
79
+ /**
80
+ * Attribute ResourceGroupId: The resource group ID.
81
+ */
82
+ readonly attrResourceGroupId: ros.IResolvable;
83
+ /**
84
+ * Attribute Service: The information about the service to which the service instance belongs.
85
+ */
86
+ readonly attrService: ros.IResolvable;
87
+ /**
88
+ * Attribute ServiceInstanceId: The ID of the service instance.
89
+ */
90
+ readonly attrServiceInstanceId: ros.IResolvable;
91
+ /**
92
+ * Attribute ServiceInstanceName: The name of the resource.
93
+ */
94
+ readonly attrServiceInstanceName: ros.IResolvable;
95
+ /**
96
+ * Attribute ServiceType: The type of the service.
97
+ */
98
+ readonly attrServiceType: ros.IResolvable;
99
+ /**
100
+ * Attribute Source: The source of the service instance.
101
+ */
102
+ readonly attrSource: ros.IResolvable;
103
+ /**
104
+ * Attribute StatusDetail: The description of the deployment state of the service instance.
105
+ */
106
+ readonly attrStatusDetail: ros.IResolvable;
107
+ /**
108
+ * Attribute SupplierUid: The Alibaba Cloud account ID of the service provider.
109
+ */
110
+ readonly attrSupplierUid: ros.IResolvable;
111
+ /**
112
+ * Attribute Tags: The tags of the service instance.
113
+ */
114
+ readonly attrTags: ros.IResolvable;
115
+ /**
116
+ * Attribute TemplateName: The name of the template.
117
+ */
118
+ readonly attrTemplateName: ros.IResolvable;
119
+ /**
120
+ * Attribute UpdateTime: The time when the serviceInstance was last updated.
121
+ */
122
+ readonly attrUpdateTime: ros.IResolvable;
123
+ /**
124
+ * Attribute UserId: The AliUid of the user.
125
+ */
126
+ readonly attrUserId: ros.IResolvable;
127
+ /**
128
+ * Param scope - scope in which this resource is defined
129
+ * Param id - scoped id of the resource
130
+ * Param props - resource properties
131
+ */
132
+ constructor(scope: ros.Construct, id: string, props: ServiceInstanceProps, enableResourcePropertyConstraint?: boolean);
133
+ }
package/lib/datasource/serviceinstance.js ADDED
@@ -0,0 +1,56 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.ServiceInstance = exports.ServiceInstanceProperty = void 0;
4
+ const ros = require("@alicloud/ros-cdk-core");
5
+ const computenest_generated_1 = require("./computenest.generated");
6
+ Object.defineProperty(exports, "ServiceInstanceProperty", { enumerable: true, get: function () { return computenest_generated_1.RosServiceInstance; } });
7
+ /**
8
+ * This class encapsulates and extends the ROS resource type `DATASOURCE::ComputeNest::ServiceInstance`.
9
+ * @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.
10
+ * See https://www.alibabacloud.com/help/ros/developer-reference/datasource-computenest-serviceinstance
11
+ */
12
+ class ServiceInstance extends ros.Resource {
13
+ /**
14
+ * Param scope - scope in which this resource is defined
15
+ * Param id - scoped id of the resource
16
+ * Param props - resource properties
17
+ */
18
+ constructor(scope, id, props, enableResourcePropertyConstraint = true) {
19
+ super(scope, id);
20
+ this.scope = scope;
21
+ this.id = id;
22
+ this.props = props;
23
+ this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
24
+ const rosServiceInstance = new computenest_generated_1.RosServiceInstance(this, id, {
25
+ serviceInstanceId: props.serviceInstanceId,
26
+ refreshOptions: props.refreshOptions === undefined || props.refreshOptions === null ? 'Never' : props.refreshOptions,
27
+ }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
28
+ this.resource = rosServiceInstance;
29
+ this.attrComponents = rosServiceInstance.attrComponents;
30
+ this.attrCreateTime = rosServiceInstance.attrCreateTime;
31
+ this.attrEnableInstanceOps = rosServiceInstance.attrEnableInstanceOps;
32
+ this.attrEnableUserPrometheus = rosServiceInstance.attrEnableUserPrometheus;
33
+ this.attrIsOperated = rosServiceInstance.attrIsOperated;
34
+ this.attrLicenseEndTime = rosServiceInstance.attrLicenseEndTime;
35
+ this.attrMarketInstanceId = rosServiceInstance.attrMarketInstanceId;
36
+ this.attrNetworkConfig = rosServiceInstance.attrNetworkConfig;
37
+ this.attrOutputs = rosServiceInstance.attrOutputs;
38
+ this.attrParameters = rosServiceInstance.attrParameters;
39
+ this.attrPredefinedParameterName = rosServiceInstance.attrPredefinedParameterName;
40
+ this.attrProgress = rosServiceInstance.attrProgress;
41
+ this.attrResourceGroupId = rosServiceInstance.attrResourceGroupId;
42
+ this.attrService = rosServiceInstance.attrService;
43
+ this.attrServiceInstanceId = rosServiceInstance.attrServiceInstanceId;
44
+ this.attrServiceInstanceName = rosServiceInstance.attrServiceInstanceName;
45
+ this.attrServiceType = rosServiceInstance.attrServiceType;
46
+ this.attrSource = rosServiceInstance.attrSource;
47
+ this.attrStatusDetail = rosServiceInstance.attrStatusDetail;
48
+ this.attrSupplierUid = rosServiceInstance.attrSupplierUid;
49
+ this.attrTags = rosServiceInstance.attrTags;
50
+ this.attrTemplateName = rosServiceInstance.attrTemplateName;
51
+ this.attrUpdateTime = rosServiceInstance.attrUpdateTime;
52
+ this.attrUserId = rosServiceInstance.attrUserId;
53
+ }
54
+ }
55
+ exports.ServiceInstance = ServiceInstance;
56
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serviceinstance.js","sourceRoot":"","sources":["serviceinstance.ts"],"names":[],"mappings":";;;AAAA,8CAA8C;AAC9C,mEAA6D;AAE9B,wGAFtB,0CAAkB,OAE2B;AAsBtD;;;;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 * 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 {\n    protected scope: ros.Construct;\n    protected id: string;\n    protected props: ServiceInstanceProps;\n    protected enableResourcePropertyConstraint: boolean;\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    /**\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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@alicloud/ros-cdk-computenest",
3
- "version": "1.4.0",
3
+ "version": "1.5.0",
4
4
  "description": "Aliyun SDK Copyright (C) Alibaba Cloud Computing All rights reserved. http://www.aliyun.com",
5
5
  "author": "ROS Development Team",
6
6
  "license": "Apache-2.0",