@alicloud/ros-cdk-nlb 1.0.14 → 1.0.16

package/lib/datasource/index.d.ts

@@ -0,0 +1,2 @@
+export * from './loadbalancers';
+export * from './nlb.generated';

package/lib/datasource/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./loadbalancers"), exports);
+// DATASOURCE::NLB Resources:
+__exportStar(require("./nlb.generated"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSxrREFBZ0M7QUFFaEMsNkJBQTZCO0FBQzdCLGtEQUFnQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbG9hZGJhbGFuY2Vycyc7XG5cbi8vIERBVEFTT1VSQ0U6Ok5MQiBSZXNvdXJjZXM6XG5leHBvcnQgKiBmcm9tICcuL25sYi5nZW5lcmF0ZWQnO1xuIl19

package/lib/datasource/loadbalancers.d.ts

@@ -0,0 +1,77 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosLoadBalancers } from './nlb.generated';
+export { RosLoadBalancers as LoadBalancersProperty };
+/**
+ * Properties for defining a `DATASOURCE::NLB::LoadBalancers`
+ */
+export interface LoadBalancersProps {
+    /**
+     * Property addressIpVersion: IP version.
+     */
+    readonly addressIpVersion?: string | ros.IResolvable;
+    /**
+     * Property addressType: The address type of the load balancing instance.
+     */
+    readonly addressType?: string | ros.IResolvable;
+    /**
+     * Property ipv6AddressType: IPv6 address type of network load balancing
+     */
+    readonly ipv6AddressType?: string | ros.IResolvable;
+    /**
+     * Property loadBalancerBussinessStatus: Service status of application load balancing
+     */
+    readonly loadBalancerBussinessStatus?: string | ros.IResolvable;
+    /**
+     * Property loadBalancerIds: IDs of the load balancer instance.
+     */
+    readonly loadBalancerIds?: Array<string | ros.IResolvable> | ros.IResolvable;
+    /**
+     * Property loadBalancerNames: Names of the load balancing instance.
+     */
+    readonly loadBalancerNames?: Array<string | ros.IResolvable> | ros.IResolvable;
+    /**
+     * Property loadBalancerStatus: The status of SLB.
+     */
+    readonly loadBalancerStatus?: string | ros.IResolvable;
+    /**
+     * Property resourceGroupId: Resource group id
+     */
+    readonly resourceGroupId?: string | ros.IResolvable;
+    /**
+     * Property tags: Tags of Nlb.
+     */
+    readonly tags?: RosLoadBalancers.TagsProperty[];
+    /**
+     * Property vpcIds: VPC IDs
+     */
+    readonly vpcIds?: Array<string | ros.IResolvable> | ros.IResolvable;
+    /**
+     * Property zoneId: ID of the ready-to-use zone of the load balancing instance.
+     */
+    readonly zoneId?: string | ros.IResolvable;
+}
+/**
+ * A ROS resource type:  `DATASOURCE::NLB::LoadBalancers`
+ */
+export declare class LoadBalancers extends ros.Resource {
+    /**
+     * A factory method that creates a new instance of this class from an object
+     * containing the properties of this ROS resource, which will be assigned to ROS resource.
+     */
+    /**
+     * Attribute LoadBalancerIds: The list of load balancer IDs.
+     */
+    readonly attrLoadBalancerIds: ros.IResolvable;
+    /**
+     * Attribute LoadBalancers: The list of load balancers.
+     */
+    readonly attrLoadBalancers: ros.IResolvable;
+    /**
+     * Create a new `DATASOURCE::NLB::LoadBalancers`.
+     *
+     * 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?: LoadBalancersProps, enableResourcePropertyConstraint?: boolean);
+}

package/lib/datasource/loadbalancers.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadBalancers = exports.LoadBalancersProperty = void 0;
+const ros = require("@alicloud/ros-cdk-core");
+const nlb_generated_1 = require("./nlb.generated");
+Object.defineProperty(exports, "LoadBalancersProperty", { enumerable: true, get: function () { return nlb_generated_1.RosLoadBalancers; } });
+/**
+ * A ROS resource type:  `DATASOURCE::NLB::LoadBalancers`
+ */
+class LoadBalancers extends ros.Resource {
+    /**
+     * Create a new `DATASOURCE::NLB::LoadBalancers`.
+     *
+     * 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);
+        const rosLoadBalancers = new nlb_generated_1.RosLoadBalancers(this, id, {
+            loadBalancerNames: props.loadBalancerNames,
+            addressIpVersion: props.addressIpVersion,
+            loadBalancerBussinessStatus: props.loadBalancerBussinessStatus,
+            zoneId: props.zoneId,
+            resourceGroupId: props.resourceGroupId,
+            vpcIds: props.vpcIds,
+            loadBalancerIds: props.loadBalancerIds,
+            addressType: props.addressType,
+            loadBalancerStatus: props.loadBalancerStatus,
+            tags: props.tags,
+            ipv6AddressType: props.ipv6AddressType,
+        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
+        this.resource = rosLoadBalancers;
+        this.attrLoadBalancerIds = rosLoadBalancers.attrLoadBalancerIds;
+        this.attrLoadBalancers = rosLoadBalancers.attrLoadBalancers;
+    }
+}
+exports.LoadBalancers = LoadBalancers;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,147 @@
+import * as ros from '@alicloud/ros-cdk-core';
+/**
+ * Properties for defining a `DATASOURCE::NLB::LoadBalancers`
+ */
+export interface RosLoadBalancersProps {
+    /**
+     * @Property addressIpVersion: IP version.
+     */
+    readonly addressIpVersion?: string | ros.IResolvable;
+    /**
+     * @Property addressType: The address type of the load balancing instance.
+     */
+    readonly addressType?: string | ros.IResolvable;
+    /**
+     * @Property ipv6AddressType: IPv6 address type of network load balancing
+     */
+    readonly ipv6AddressType?: string | ros.IResolvable;
+    /**
+     * @Property loadBalancerBussinessStatus: Service status of application load balancing
+     */
+    readonly loadBalancerBussinessStatus?: string | ros.IResolvable;
+    /**
+     * @Property loadBalancerIds: IDs of the load balancer instance.
+     */
+    readonly loadBalancerIds?: Array<string | ros.IResolvable> | ros.IResolvable;
+    /**
+     * @Property loadBalancerNames: Names of the load balancing instance.
+     */
+    readonly loadBalancerNames?: Array<string | ros.IResolvable> | ros.IResolvable;
+    /**
+     * @Property loadBalancerStatus: The status of SLB.
+     */
+    readonly loadBalancerStatus?: string | ros.IResolvable;
+    /**
+     * @Property resourceGroupId: Resource group id
+     */
+    readonly resourceGroupId?: string | ros.IResolvable;
+    /**
+     * @Property tags: Tags of Nlb.
+     */
+    readonly tags?: RosLoadBalancers.TagsProperty[];
+    /**
+     * @Property vpcIds: VPC IDs
+     */
+    readonly vpcIds?: Array<string | ros.IResolvable> | ros.IResolvable;
+    /**
+     * @Property zoneId: ID of the ready-to-use zone of the load balancing instance.
+     */
+    readonly zoneId?: string | ros.IResolvable;
+}
+/**
+ * A ROS template type:  `DATASOURCE::NLB::LoadBalancers`
+ */
+export declare class RosLoadBalancers extends ros.RosResource {
+    /**
+     * The resource type name for this resource class.
+     */
+    static readonly ROS_RESOURCE_TYPE_NAME = "DATASOURCE::NLB::LoadBalancers";
+    /**
+     * A factory method that creates a new instance of this class from an object
+     * containing the properties of this ROS resource.
+     */
+    /**
+     * @Attribute LoadBalancerIds: The list of load balancer IDs.
+     */
+    readonly attrLoadBalancerIds: ros.IResolvable;
+    /**
+     * @Attribute LoadBalancers: The list of load balancers.
+     */
+    readonly attrLoadBalancers: ros.IResolvable;
+    enableResourcePropertyConstraint: boolean;
+    /**
+     * @Property addressIpVersion: IP version.
+     */
+    addressIpVersion: string | ros.IResolvable | undefined;
+    /**
+     * @Property addressType: The address type of the load balancing instance.
+     */
+    addressType: string | ros.IResolvable | undefined;
+    /**
+     * @Property ipv6AddressType: IPv6 address type of network load balancing
+     */
+    ipv6AddressType: string | ros.IResolvable | undefined;
+    /**
+     * @Property loadBalancerBussinessStatus: Service status of application load balancing
+     */
+    loadBalancerBussinessStatus: string | ros.IResolvable | undefined;
+    /**
+     * @Property loadBalancerIds: IDs of the load balancer instance.
+     */
+    loadBalancerIds: Array<string | ros.IResolvable> | ros.IResolvable | undefined;
+    /**
+     * @Property loadBalancerNames: Names of the load balancing instance.
+     */
+    loadBalancerNames: Array<string | ros.IResolvable> | ros.IResolvable | undefined;
+    /**
+     * @Property loadBalancerStatus: The status of SLB.
+     */
+    loadBalancerStatus: string | ros.IResolvable | undefined;
+    /**
+     * @Property resourceGroupId: Resource group id
+     */
+    resourceGroupId: string | ros.IResolvable | undefined;
+    /**
+     * @Property tags: Tags of Nlb.
+     */
+    tags: RosLoadBalancers.TagsProperty[] | undefined;
+    /**
+     * @Property vpcIds: VPC IDs
+     */
+    vpcIds: Array<string | ros.IResolvable> | ros.IResolvable | undefined;
+    /**
+     * @Property zoneId: ID of the ready-to-use zone of the load balancing instance.
+     */
+    zoneId: string | ros.IResolvable | undefined;
+    /**
+     * Create a new `DATASOURCE::NLB::LoadBalancers`.
+     *
+     * @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: RosLoadBalancersProps, enableResourcePropertyConstraint: boolean);
+    protected get rosProperties(): {
+        [key: string]: any;
+    };
+    protected renderProperties(props: {
+        [key: string]: any;
+    }): {
+        [key: string]: any;
+    };
+}
+export declare namespace RosLoadBalancers {
+    /**
+     * @stability external
+     */
+    interface TagsProperty {
+        /**
+         * @Property value: undefined
+         */
+        readonly value?: string | ros.IResolvable;
+        /**
+         * @Property key: undefined
+         */
+        readonly key: string | ros.IResolvable;
+    }
+}

package/lib/datasource/nlb.generated.js

@@ -0,0 +1,193 @@
+"use strict";
+// Generated from the AliCloud ROS Resource Specification
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RosLoadBalancers = void 0;
+const ros = require("@alicloud/ros-cdk-core");
+/**
+ * Determine whether the given properties match those of a `RosLoadBalancersProps`
+ *
+ * @param properties - the TypeScript properties of a `RosLoadBalancersProps`
+ *
+ * @returns the result of the validation.
+ */
+function RosLoadBalancersPropsValidator(properties) {
+    if (!ros.canInspect(properties)) {
+        return ros.VALIDATION_SUCCESS;
+    }
+    const errors = new ros.ValidationResults();
+    if (properties.loadBalancerNames && (Array.isArray(properties.loadBalancerNames) || (typeof properties.loadBalancerNames) === 'string')) {
+        errors.collect(ros.propertyValidator('loadBalancerNames', ros.validateLength)({
+            data: properties.loadBalancerNames.length,
+            min: 0,
+            max: 10,
+        }));
+    }
+    errors.collect(ros.propertyValidator('loadBalancerNames', ros.listValidator(ros.validateString))(properties.loadBalancerNames));
+    errors.collect(ros.propertyValidator('addressIpVersion', ros.validateString)(properties.addressIpVersion));
+    if (properties.loadBalancerBussinessStatus && (typeof properties.loadBalancerBussinessStatus) !== 'object') {
+        errors.collect(ros.propertyValidator('loadBalancerBussinessStatus', ros.validateAllowedValues)({
+            data: properties.loadBalancerBussinessStatus,
+            allowedValues: ["Abnormal", "Normal"],
+        }));
+    }
+    errors.collect(ros.propertyValidator('loadBalancerBussinessStatus', ros.validateString)(properties.loadBalancerBussinessStatus));
+    errors.collect(ros.propertyValidator('zoneId', ros.validateString)(properties.zoneId));
+    errors.collect(ros.propertyValidator('resourceGroupId', ros.validateString)(properties.resourceGroupId));
+    if (properties.vpcIds && (Array.isArray(properties.vpcIds) || (typeof properties.vpcIds) === 'string')) {
+        errors.collect(ros.propertyValidator('vpcIds', ros.validateLength)({
+            data: properties.vpcIds.length,
+            min: 0,
+            max: 10,
+        }));
+    }
+    errors.collect(ros.propertyValidator('vpcIds', ros.listValidator(ros.validateString))(properties.vpcIds));
+    if (properties.loadBalancerIds && (Array.isArray(properties.loadBalancerIds) || (typeof properties.loadBalancerIds) === 'string')) {
+        errors.collect(ros.propertyValidator('loadBalancerIds', ros.validateLength)({
+            data: properties.loadBalancerIds.length,
+            min: 0,
+            max: 20,
+        }));
+    }
+    errors.collect(ros.propertyValidator('loadBalancerIds', ros.listValidator(ros.validateString))(properties.loadBalancerIds));
+    if (properties.addressType && (typeof properties.addressType) !== 'object') {
+        errors.collect(ros.propertyValidator('addressType', ros.validateAllowedValues)({
+            data: properties.addressType,
+            allowedValues: ["Internet", "Intranet"],
+        }));
+    }
+    errors.collect(ros.propertyValidator('addressType', ros.validateString)(properties.addressType));
+    if (properties.loadBalancerStatus && (typeof properties.loadBalancerStatus) !== 'object') {
+        errors.collect(ros.propertyValidator('loadBalancerStatus', ros.validateAllowedValues)({
+            data: properties.loadBalancerStatus,
+            allowedValues: ["Inactive", "Active", "Provisioning", "Configuring", "Deleting", "Deleted"],
+        }));
+    }
+    errors.collect(ros.propertyValidator('loadBalancerStatus', ros.validateString)(properties.loadBalancerStatus));
+    if (properties.tags && (Array.isArray(properties.tags) || (typeof properties.tags) === 'string')) {
+        errors.collect(ros.propertyValidator('tags', ros.validateLength)({
+            data: properties.tags.length,
+            min: undefined,
+            max: 20,
+        }));
+    }
+    errors.collect(ros.propertyValidator('tags', ros.listValidator(RosLoadBalancers_TagsPropertyValidator))(properties.tags));
+    errors.collect(ros.propertyValidator('ipv6AddressType', ros.validateString)(properties.ipv6AddressType));
+    return errors.wrap('supplied properties not correct for "RosLoadBalancersProps"');
+}
+/**
+ * Renders the AliCloud ROS Resource properties of an `DATASOURCE::NLB::LoadBalancers` resource
+ *
+ * @param properties - the TypeScript properties of a `RosLoadBalancersProps`
+ *
+ * @returns the AliCloud ROS Resource properties of an `DATASOURCE::NLB::LoadBalancers` resource.
+ */
+// @ts-ignore TS6133
+function rosLoadBalancersPropsToRosTemplate(properties, enableResourcePropertyConstraint) {
+    if (!ros.canInspect(properties)) {
+        return properties;
+    }
+    if (enableResourcePropertyConstraint) {
+        RosLoadBalancersPropsValidator(properties).assertSuccess();
+    }
+    return {
+        AddressIpVersion: ros.stringToRosTemplate(properties.addressIpVersion),
+        AddressType: ros.stringToRosTemplate(properties.addressType),
+        Ipv6AddressType: ros.stringToRosTemplate(properties.ipv6AddressType),
+        LoadBalancerBussinessStatus: ros.stringToRosTemplate(properties.loadBalancerBussinessStatus),
+        LoadBalancerIds: ros.listMapper(ros.stringToRosTemplate)(properties.loadBalancerIds),
+        LoadBalancerNames: ros.listMapper(ros.stringToRosTemplate)(properties.loadBalancerNames),
+        LoadBalancerStatus: ros.stringToRosTemplate(properties.loadBalancerStatus),
+        ResourceGroupId: ros.stringToRosTemplate(properties.resourceGroupId),
+        Tags: ros.listMapper(rosLoadBalancersTagsPropertyToRosTemplate)(properties.tags),
+        VpcIds: ros.listMapper(ros.stringToRosTemplate)(properties.vpcIds),
+        ZoneId: ros.stringToRosTemplate(properties.zoneId),
+    };
+}
+/**
+ * A ROS template type:  `DATASOURCE::NLB::LoadBalancers`
+ */
+class RosLoadBalancers extends ros.RosResource {
+    /**
+     * Create a new `DATASOURCE::NLB::LoadBalancers`.
+     *
+     * @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: RosLoadBalancers.ROS_RESOURCE_TYPE_NAME, properties: props });
+        this.attrLoadBalancerIds = this.getAtt('LoadBalancerIds');
+        this.attrLoadBalancers = this.getAtt('LoadBalancers');
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
+        this.addressIpVersion = props.addressIpVersion;
+        this.addressType = props.addressType;
+        this.ipv6AddressType = props.ipv6AddressType;
+        this.loadBalancerBussinessStatus = props.loadBalancerBussinessStatus;
+        this.loadBalancerIds = props.loadBalancerIds;
+        this.loadBalancerNames = props.loadBalancerNames;
+        this.loadBalancerStatus = props.loadBalancerStatus;
+        this.resourceGroupId = props.resourceGroupId;
+        this.tags = props.tags;
+        this.vpcIds = props.vpcIds;
+        this.zoneId = props.zoneId;
+    }
+    get rosProperties() {
+        return {
+            addressIpVersion: this.addressIpVersion,
+            addressType: this.addressType,
+            ipv6AddressType: this.ipv6AddressType,
+            loadBalancerBussinessStatus: this.loadBalancerBussinessStatus,
+            loadBalancerIds: this.loadBalancerIds,
+            loadBalancerNames: this.loadBalancerNames,
+            loadBalancerStatus: this.loadBalancerStatus,
+            resourceGroupId: this.resourceGroupId,
+            tags: this.tags,
+            vpcIds: this.vpcIds,
+            zoneId: this.zoneId,
+        };
+    }
+    renderProperties(props) {
+        return rosLoadBalancersPropsToRosTemplate(props, this.enableResourcePropertyConstraint);
+    }
+}
+exports.RosLoadBalancers = RosLoadBalancers;
+/**
+ * The resource type name for this resource class.
+ */
+RosLoadBalancers.ROS_RESOURCE_TYPE_NAME = "DATASOURCE::NLB::LoadBalancers";
+/**
+ * Determine whether the given properties match those of a `TagsProperty`
+ *
+ * @param properties - the TypeScript properties of a `TagsProperty`
+ *
+ * @returns the result of the validation.
+ */
+function RosLoadBalancers_TagsPropertyValidator(properties) {
+    if (!ros.canInspect(properties)) {
+        return ros.VALIDATION_SUCCESS;
+    }
+    const errors = new ros.ValidationResults();
+    errors.collect(ros.propertyValidator('value', ros.validateString)(properties.value));
+    errors.collect(ros.propertyValidator('key', ros.requiredValidator)(properties.key));
+    errors.collect(ros.propertyValidator('key', ros.validateString)(properties.key));
+    return errors.wrap('supplied properties not correct for "TagsProperty"');
+}
+/**
+ * Renders the AliCloud ROS Resource properties of an `DATASOURCE::NLB::LoadBalancers.Tags` resource
+ *
+ * @param properties - the TypeScript properties of a `TagsProperty`
+ *
+ * @returns the AliCloud ROS Resource properties of an `DATASOURCE::NLB::LoadBalancers.Tags` resource.
+ */
+// @ts-ignore TS6133
+function rosLoadBalancersTagsPropertyToRosTemplate(properties) {
+    if (!ros.canInspect(properties)) {
+        return properties;
+    }
+    RosLoadBalancers_TagsPropertyValidator(properties).assertSuccess();
+    return {
+        Value: ros.stringToRosTemplate(properties.value),
+        Key: ros.stringToRosTemplate(properties.key),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nlb.generated.js","sourceRoot":"","sources":["nlb.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 `DATASOURCE::NLB::LoadBalancers`\n */\nexport interface RosLoadBalancersProps {\n\n    /**\n     * @Property addressIpVersion: IP version.\n     */\n    readonly addressIpVersion?: string | ros.IResolvable;\n\n    /**\n     * @Property addressType: The address type of the load balancing instance.\n     */\n    readonly addressType?: string | ros.IResolvable;\n\n    /**\n     * @Property ipv6AddressType: IPv6 address type of network load balancing\n     */\n    readonly ipv6AddressType?: string | ros.IResolvable;\n\n    /**\n     * @Property loadBalancerBussinessStatus: Service status of application load balancing\n     */\n    readonly loadBalancerBussinessStatus?: string | ros.IResolvable;\n\n    /**\n     * @Property loadBalancerIds: IDs of the load balancer instance.\n     */\n    readonly loadBalancerIds?: Array<string | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property loadBalancerNames: Names of the load balancing instance.\n     */\n    readonly loadBalancerNames?: Array<string | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property loadBalancerStatus: The status of SLB.\n     */\n    readonly loadBalancerStatus?: string | ros.IResolvable;\n\n    /**\n     * @Property resourceGroupId: Resource group id\n     */\n    readonly resourceGroupId?: string | ros.IResolvable;\n\n    /**\n     * @Property tags: Tags of Nlb.\n     */\n    readonly tags?: RosLoadBalancers.TagsProperty[];\n\n    /**\n     * @Property vpcIds: VPC IDs\n     */\n    readonly vpcIds?: Array<string | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property zoneId: ID of the ready-to-use zone of the load balancing instance.\n     */\n    readonly zoneId?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosLoadBalancersProps`\n *\n * @param properties - the TypeScript properties of a `RosLoadBalancersProps`\n *\n * @returns the result of the validation.\n */\nfunction RosLoadBalancersPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    if(properties.loadBalancerNames && (Array.isArray(properties.loadBalancerNames) || (typeof properties.loadBalancerNames) === 'string')) {\n        errors.collect(ros.propertyValidator('loadBalancerNames', ros.validateLength)({\n            data: properties.loadBalancerNames.length,\n            min: 0,\n            max: 10,\n          }));\n    }\n    errors.collect(ros.propertyValidator('loadBalancerNames', ros.listValidator(ros.validateString))(properties.loadBalancerNames));\n    errors.collect(ros.propertyValidator('addressIpVersion', ros.validateString)(properties.addressIpVersion));\n    if(properties.loadBalancerBussinessStatus && (typeof properties.loadBalancerBussinessStatus) !== 'object') {\n        errors.collect(ros.propertyValidator('loadBalancerBussinessStatus', ros.validateAllowedValues)({\n          data: properties.loadBalancerBussinessStatus,\n          allowedValues: [\"Abnormal\",\"Normal\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('loadBalancerBussinessStatus', ros.validateString)(properties.loadBalancerBussinessStatus));\n    errors.collect(ros.propertyValidator('zoneId', ros.validateString)(properties.zoneId));\n    errors.collect(ros.propertyValidator('resourceGroupId', ros.validateString)(properties.resourceGroupId));\n    if(properties.vpcIds && (Array.isArray(properties.vpcIds) || (typeof properties.vpcIds) === 'string')) {\n        errors.collect(ros.propertyValidator('vpcIds', ros.validateLength)({\n            data: properties.vpcIds.length,\n            min: 0,\n            max: 10,\n          }));\n    }\n    errors.collect(ros.propertyValidator('vpcIds', ros.listValidator(ros.validateString))(properties.vpcIds));\n    if(properties.loadBalancerIds && (Array.isArray(properties.loadBalancerIds) || (typeof properties.loadBalancerIds) === 'string')) {\n        errors.collect(ros.propertyValidator('loadBalancerIds', ros.validateLength)({\n            data: properties.loadBalancerIds.length,\n            min: 0,\n            max: 20,\n          }));\n    }\n    errors.collect(ros.propertyValidator('loadBalancerIds', ros.listValidator(ros.validateString))(properties.loadBalancerIds));\n    if(properties.addressType && (typeof properties.addressType) !== 'object') {\n        errors.collect(ros.propertyValidator('addressType', ros.validateAllowedValues)({\n          data: properties.addressType,\n          allowedValues: [\"Internet\",\"Intranet\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('addressType', ros.validateString)(properties.addressType));\n    if(properties.loadBalancerStatus && (typeof properties.loadBalancerStatus) !== 'object') {\n        errors.collect(ros.propertyValidator('loadBalancerStatus', ros.validateAllowedValues)({\n          data: properties.loadBalancerStatus,\n          allowedValues: [\"Inactive\",\"Active\",\"Provisioning\",\"Configuring\",\"Deleting\",\"Deleted\"],\n        }));\n    }\n    errors.collect(ros.propertyValidator('loadBalancerStatus', ros.validateString)(properties.loadBalancerStatus));\n    if(properties.tags && (Array.isArray(properties.tags) || (typeof properties.tags) === 'string')) {\n        errors.collect(ros.propertyValidator('tags', ros.validateLength)({\n            data: properties.tags.length,\n            min: undefined,\n            max: 20,\n          }));\n    }\n    errors.collect(ros.propertyValidator('tags', ros.listValidator(RosLoadBalancers_TagsPropertyValidator))(properties.tags));\n    errors.collect(ros.propertyValidator('ipv6AddressType', ros.validateString)(properties.ipv6AddressType));\n    return errors.wrap('supplied properties not correct for \"RosLoadBalancersProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::NLB::LoadBalancers` resource\n *\n * @param properties - the TypeScript properties of a `RosLoadBalancersProps`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::NLB::LoadBalancers` resource.\n */\n// @ts-ignore TS6133\nfunction rosLoadBalancersPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosLoadBalancersPropsValidator(properties).assertSuccess();\n    }\n    return {\n      AddressIpVersion: ros.stringToRosTemplate(properties.addressIpVersion),\n      AddressType: ros.stringToRosTemplate(properties.addressType),\n      Ipv6AddressType: ros.stringToRosTemplate(properties.ipv6AddressType),\n      LoadBalancerBussinessStatus: ros.stringToRosTemplate(properties.loadBalancerBussinessStatus),\n      LoadBalancerIds: ros.listMapper(ros.stringToRosTemplate)(properties.loadBalancerIds),\n      LoadBalancerNames: ros.listMapper(ros.stringToRosTemplate)(properties.loadBalancerNames),\n      LoadBalancerStatus: ros.stringToRosTemplate(properties.loadBalancerStatus),\n      ResourceGroupId: ros.stringToRosTemplate(properties.resourceGroupId),\n      Tags: ros.listMapper(rosLoadBalancersTagsPropertyToRosTemplate)(properties.tags),\n      VpcIds: ros.listMapper(ros.stringToRosTemplate)(properties.vpcIds),\n      ZoneId: ros.stringToRosTemplate(properties.zoneId),\n    };\n}\n\n/**\n * A ROS template type:  `DATASOURCE::NLB::LoadBalancers`\n */\nexport class RosLoadBalancers extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"DATASOURCE::NLB::LoadBalancers\";\n\n    /**\n     * A factory method that creates a new instance of this class from an object\n     * containing the properties of this ROS resource.\n     */\n\n    /**\n     * @Attribute LoadBalancerIds: The list of load balancer IDs.\n     */\n    public readonly attrLoadBalancerIds: ros.IResolvable;\n\n    /**\n     * @Attribute LoadBalancers: The list of load balancers.\n     */\n    public readonly attrLoadBalancers: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property addressIpVersion: IP version.\n     */\n    public addressIpVersion: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property addressType: The address type of the load balancing instance.\n     */\n    public addressType: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property ipv6AddressType: IPv6 address type of network load balancing\n     */\n    public ipv6AddressType: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property loadBalancerBussinessStatus: Service status of application load balancing\n     */\n    public loadBalancerBussinessStatus: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property loadBalancerIds: IDs of the load balancer instance.\n     */\n    public loadBalancerIds: Array<string | ros.IResolvable> | ros.IResolvable | undefined;\n\n    /**\n     * @Property loadBalancerNames: Names of the load balancing instance.\n     */\n    public loadBalancerNames: Array<string | ros.IResolvable> | ros.IResolvable | undefined;\n\n    /**\n     * @Property loadBalancerStatus: The status of SLB.\n     */\n    public loadBalancerStatus: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property resourceGroupId: Resource group id\n     */\n    public resourceGroupId: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property tags: Tags of Nlb.\n     */\n    public tags: RosLoadBalancers.TagsProperty[] | undefined;\n\n    /**\n     * @Property vpcIds: VPC IDs\n     */\n    public vpcIds: Array<string | ros.IResolvable> | ros.IResolvable | undefined;\n\n    /**\n     * @Property zoneId: ID of the ready-to-use zone of the load balancing instance.\n     */\n    public zoneId: string | ros.IResolvable | undefined;\n\n    /**\n     * Create a new `DATASOURCE::NLB::LoadBalancers`.\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: RosLoadBalancersProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosLoadBalancers.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrLoadBalancerIds = this.getAtt('LoadBalancerIds');\n        this.attrLoadBalancers = this.getAtt('LoadBalancers');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.addressIpVersion = props.addressIpVersion;\n        this.addressType = props.addressType;\n        this.ipv6AddressType = props.ipv6AddressType;\n        this.loadBalancerBussinessStatus = props.loadBalancerBussinessStatus;\n        this.loadBalancerIds = props.loadBalancerIds;\n        this.loadBalancerNames = props.loadBalancerNames;\n        this.loadBalancerStatus = props.loadBalancerStatus;\n        this.resourceGroupId = props.resourceGroupId;\n        this.tags = props.tags;\n        this.vpcIds = props.vpcIds;\n        this.zoneId = props.zoneId;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            addressIpVersion: this.addressIpVersion,\n            addressType: this.addressType,\n            ipv6AddressType: this.ipv6AddressType,\n            loadBalancerBussinessStatus: this.loadBalancerBussinessStatus,\n            loadBalancerIds: this.loadBalancerIds,\n            loadBalancerNames: this.loadBalancerNames,\n            loadBalancerStatus: this.loadBalancerStatus,\n            resourceGroupId: this.resourceGroupId,\n            tags: this.tags,\n            vpcIds: this.vpcIds,\n            zoneId: this.zoneId,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosLoadBalancersPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\nexport namespace RosLoadBalancers {\n    /**\n     * @stability external\n     */\n    export interface TagsProperty {\n        /**\n         * @Property value: undefined\n         */\n        readonly value?: string | ros.IResolvable;\n        /**\n         * @Property key: undefined\n         */\n        readonly key: string | ros.IResolvable;\n    }\n}\n/**\n * Determine whether the given properties match those of a `TagsProperty`\n *\n * @param properties - the TypeScript properties of a `TagsProperty`\n *\n * @returns the result of the validation.\n */\nfunction RosLoadBalancers_TagsPropertyValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('value', ros.validateString)(properties.value));\n    errors.collect(ros.propertyValidator('key', ros.requiredValidator)(properties.key));\n    errors.collect(ros.propertyValidator('key', ros.validateString)(properties.key));\n    return errors.wrap('supplied properties not correct for \"TagsProperty\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `DATASOURCE::NLB::LoadBalancers.Tags` resource\n *\n * @param properties - the TypeScript properties of a `TagsProperty`\n *\n * @returns the AliCloud ROS Resource properties of an `DATASOURCE::NLB::LoadBalancers.Tags` resource.\n */\n// @ts-ignore TS6133\nfunction rosLoadBalancersTagsPropertyToRosTemplate(properties: any): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    RosLoadBalancers_TagsPropertyValidator(properties).assertSuccess();\n    return {\n      Value: ros.stringToRosTemplate(properties.value),\n      Key: ros.stringToRosTemplate(properties.key),\n    };\n}\n"]}

package/lib/index.d.ts

@@ -2,3 +2,5 @@ export * from './listener';
 export * from './loadbalancer';
 export * from './servergroup';
 export * from './nlb.generated';
+import * as datasource from './datasource';
+export { datasource };

package/lib/index.js

@@ -10,9 +10,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.datasource = void 0;
 __exportStar(require("./listener"), exports);
 __exportStar(require("./loadbalancer"), exports);
 __exportStar(require("./servergroup"), exports);
 // ALIYUN::NLB Resources:
 __exportStar(require("./nlb.generated"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw2Q0FBMkI7QUFDM0IsaURBQStCO0FBQy9CLGdEQUE4QjtBQUU5Qix5QkFBeUI7QUFDekIsa0RBQWdDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saXN0ZW5lcic7XG5leHBvcnQgKiBmcm9tICcuL2xvYWRiYWxhbmNlcic7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZlcmdyb3VwJztcblxuLy8gQUxJWVVOOjpOTEIgUmVzb3VyY2VzOlxuZXhwb3J0ICogZnJvbSAnLi9ubGIuZ2VuZXJhdGVkJztcbiJdfQ==
+const datasource = require("./datasource");
+exports.datasource = datasource;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7O0FBQUEsNkNBQTJCO0FBQzNCLGlEQUErQjtBQUMvQixnREFBOEI7QUFFOUIseUJBQXlCO0FBQ3pCLGtEQUFnQztBQUNoQywyQ0FBMkM7QUFDbEMsZ0NBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpc3RlbmVyJztcbmV4cG9ydCAqIGZyb20gJy4vbG9hZGJhbGFuY2VyJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmVyZ3JvdXAnO1xuXG4vLyBBTElZVU46Ok5MQiBSZXNvdXJjZXM6XG5leHBvcnQgKiBmcm9tICcuL25sYi5nZW5lcmF0ZWQnO1xuaW1wb3J0ICogYXMgZGF0YXNvdXJjZSBmcm9tICcuL2RhdGFzb3VyY2UnO1xuZXhwb3J0IHsgZGF0YXNvdXJjZSB9O1xuIl19

package/package.json

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