@alicloud/ros-cdk-devops 1.0.24 → 1.0.26

package/lib/devops.generated.d.ts

@@ -1,4 +1,151 @@
 import * as ros from '@alicloud/ros-cdk-core';
+/**
+ * Properties for defining a `RosHostGroup`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-hostgroup
+ */
+export interface RosHostGroupProps {
+    /**
+     * @Property name: Host group name.
+     */
+    readonly name: string | ros.IResolvable;
+    /**
+     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.
+     */
+    readonly organizationId: string | ros.IResolvable;
+    /**
+     * @Property serviceConnectionId: Service connection.
+     */
+    readonly serviceConnectionId: number | ros.IResolvable;
+    /**
+     * @Property aliyunRegion: The aliyun region.
+     */
+    readonly aliyunRegion?: string | ros.IResolvable;
+    /**
+     * @Property ecsLabelKey: The tag key of the ECS.
+     */
+    readonly ecsLabelKey?: string | ros.IResolvable;
+    /**
+     * @Property ecsLabelValue: The tag value of the ECS.
+     */
+    readonly ecsLabelValue?: string | ros.IResolvable;
+    /**
+     * @Property ecsType: The type of ECS, currently only supports ECS_ALIYUN.
+     */
+    readonly ecsType?: string | ros.IResolvable;
+    /**
+     * @Property envId: Environment id.
+     */
+    readonly envId?: string | ros.IResolvable;
+    /**
+     * @Property machineInfos: The machine infos
+     */
+    readonly machineInfos?: Array<RosHostGroup.MachineInfosProperty | ros.IResolvable> | ros.IResolvable;
+    /**
+     * @Property tagIds: The ids of tag.
+     */
+    readonly tagIds?: Array<string | ros.IResolvable> | ros.IResolvable;
+    /**
+     * @Property type: Host group type, currently only supports ECS.
+     */
+    readonly type?: string | ros.IResolvable;
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::HostGroup`.
+ * @Note This class does not contain additional functions, so it is recommended to use the `HostGroup` class instead of this class for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-hostgroup
+ */
+export declare class RosHostGroup extends ros.RosResource {
+    /**
+     * The resource type name for this resource class.
+     */
+    static readonly ROS_RESOURCE_TYPE_NAME = "ALIYUN::DEVOPS::HostGroup";
+    /**
+     * @Attribute HostGroupId: The id of the host group.
+     */
+    readonly attrHostGroupId: ros.IResolvable;
+    enableResourcePropertyConstraint: boolean;
+    /**
+     * @Property name: Host group name.
+     */
+    name: string | ros.IResolvable;
+    /**
+     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.
+     */
+    organizationId: string | ros.IResolvable;
+    /**
+     * @Property serviceConnectionId: Service connection.
+     */
+    serviceConnectionId: number | ros.IResolvable;
+    /**
+     * @Property aliyunRegion: The aliyun region.
+     */
+    aliyunRegion: string | ros.IResolvable | undefined;
+    /**
+     * @Property ecsLabelKey: The tag key of the ECS.
+     */
+    ecsLabelKey: string | ros.IResolvable | undefined;
+    /**
+     * @Property ecsLabelValue: The tag value of the ECS.
+     */
+    ecsLabelValue: string | ros.IResolvable | undefined;
+    /**
+     * @Property ecsType: The type of ECS, currently only supports ECS_ALIYUN.
+     */
+    ecsType: string | ros.IResolvable | undefined;
+    /**
+     * @Property envId: Environment id.
+     */
+    envId: string | ros.IResolvable | undefined;
+    /**
+     * @Property machineInfos: The machine infos
+     */
+    machineInfos: Array<RosHostGroup.MachineInfosProperty | ros.IResolvable> | ros.IResolvable | undefined;
+    /**
+     * @Property tagIds: The ids of tag.
+     */
+    tagIds: Array<string | ros.IResolvable> | ros.IResolvable | undefined;
+    /**
+     * @Property type: Host group type, currently only supports ECS.
+     */
+    type: string | ros.IResolvable | undefined;
+    /**
+     * @param scope - scope in which this resource is defined
+     * @param id    - scoped id of the resource
+     * @param props - resource properties
+     */
+    constructor(scope: ros.Construct, id: string, props: RosHostGroupProps, enableResourcePropertyConstraint: boolean);
+    protected get rosProperties(): {
+        [key: string]: any;
+    };
+    protected renderProperties(props: {
+        [key: string]: any;
+    }): {
+        [key: string]: any;
+    };
+}
+export declare namespace RosHostGroup {
+    /**
+     * @stability external
+     */
+    interface MachineInfosProperty {
+        /**
+         * @Property instanceName: The name of the instance.
+         */
+        readonly instanceName?: string | ros.IResolvable;
+        /**
+         * @Property machineSn: The id of the instance.
+         */
+        readonly machineSn: string | ros.IResolvable;
+        /**
+         * @Property ip: The ip address of the instance.
+         */
+        readonly ip?: string | ros.IResolvable;
+        /**
+         * @Property aliyunRegionId: The aliyun region of the instance.
+         */
+        readonly aliyunRegionId?: string | ros.IResolvable;
+    }
+}
 /**
  * Properties for defining a `RosPipeline`.
  * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipeline

package/lib/devops.generated.js

@@ -1,8 +1,162 @@
 "use strict";
 // Generated from the AliCloud ROS Resource Specification
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RosVariableGroup = exports.RosPipelineRun = exports.RosPipelineRelations = exports.RosPipeline = void 0;
+exports.RosVariableGroup = exports.RosPipelineRun = exports.RosPipelineRelations = exports.RosPipeline = exports.RosHostGroup = void 0;
 const ros = require("@alicloud/ros-cdk-core");
+/**
+ * Determine whether the given properties match those of a `RosHostGroupProps`
+ *
+ * @param properties - the TypeScript properties of a `RosHostGroupProps`
+ *
+ * @returns the result of the validation.
+ */
+function RosHostGroupPropsValidator(properties) {
+    if (!ros.canInspect(properties)) {
+        return ros.VALIDATION_SUCCESS;
+    }
+    const errors = new ros.ValidationResults();
+    errors.collect(ros.propertyValidator('type', ros.validateString)(properties.type));
+    errors.collect(ros.propertyValidator('serviceConnectionId', ros.requiredValidator)(properties.serviceConnectionId));
+    errors.collect(ros.propertyValidator('serviceConnectionId', ros.validateNumber)(properties.serviceConnectionId));
+    if (properties.tagIds && (Array.isArray(properties.tagIds) || (typeof properties.tagIds) === 'string')) {
+        errors.collect(ros.propertyValidator('tagIds', ros.validateLength)({
+            data: properties.tagIds.length,
+            min: 0,
+            max: 10,
+        }));
+    }
+    errors.collect(ros.propertyValidator('tagIds', ros.listValidator(ros.validateString))(properties.tagIds));
+    errors.collect(ros.propertyValidator('ecsType', ros.validateString)(properties.ecsType));
+    errors.collect(ros.propertyValidator('envId', ros.validateString)(properties.envId));
+    errors.collect(ros.propertyValidator('machineInfos', ros.listValidator(RosHostGroup_MachineInfosPropertyValidator))(properties.machineInfos));
+    errors.collect(ros.propertyValidator('aliyunRegion', ros.validateString)(properties.aliyunRegion));
+    errors.collect(ros.propertyValidator('ecsLabelValue', ros.validateString)(properties.ecsLabelValue));
+    errors.collect(ros.propertyValidator('organizationId', ros.requiredValidator)(properties.organizationId));
+    errors.collect(ros.propertyValidator('organizationId', ros.validateString)(properties.organizationId));
+    errors.collect(ros.propertyValidator('ecsLabelKey', ros.validateString)(properties.ecsLabelKey));
+    errors.collect(ros.propertyValidator('name', ros.requiredValidator)(properties.name));
+    errors.collect(ros.propertyValidator('name', ros.validateString)(properties.name));
+    return errors.wrap('supplied properties not correct for "RosHostGroupProps"');
+}
+/**
+ * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::HostGroup` resource
+ *
+ * @param properties - the TypeScript properties of a `RosHostGroupProps`
+ *
+ * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::HostGroup` resource.
+ */
+// @ts-ignore TS6133
+function rosHostGroupPropsToRosTemplate(properties, enableResourcePropertyConstraint) {
+    if (!ros.canInspect(properties)) {
+        return properties;
+    }
+    if (enableResourcePropertyConstraint) {
+        RosHostGroupPropsValidator(properties).assertSuccess();
+    }
+    return {
+        Name: ros.stringToRosTemplate(properties.name),
+        OrganizationId: ros.stringToRosTemplate(properties.organizationId),
+        ServiceConnectionId: ros.numberToRosTemplate(properties.serviceConnectionId),
+        AliyunRegion: ros.stringToRosTemplate(properties.aliyunRegion),
+        EcsLabelKey: ros.stringToRosTemplate(properties.ecsLabelKey),
+        EcsLabelValue: ros.stringToRosTemplate(properties.ecsLabelValue),
+        EcsType: ros.stringToRosTemplate(properties.ecsType),
+        EnvId: ros.stringToRosTemplate(properties.envId),
+        MachineInfos: ros.listMapper(rosHostGroupMachineInfosPropertyToRosTemplate)(properties.machineInfos),
+        TagIds: ros.listMapper(ros.stringToRosTemplate)(properties.tagIds),
+        Type: ros.stringToRosTemplate(properties.type),
+    };
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::HostGroup`.
+ * @Note This class does not contain additional functions, so it is recommended to use the `HostGroup` class instead of this class for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-hostgroup
+ */
+class RosHostGroup extends ros.RosResource {
+    /**
+     * @param scope - scope in which this resource is defined
+     * @param id    - scoped id of the resource
+     * @param props - resource properties
+     */
+    constructor(scope, id, props, enableResourcePropertyConstraint) {
+        super(scope, id, { type: RosHostGroup.ROS_RESOURCE_TYPE_NAME, properties: props });
+        this.attrHostGroupId = this.getAtt('HostGroupId');
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
+        this.name = props.name;
+        this.organizationId = props.organizationId;
+        this.serviceConnectionId = props.serviceConnectionId;
+        this.aliyunRegion = props.aliyunRegion;
+        this.ecsLabelKey = props.ecsLabelKey;
+        this.ecsLabelValue = props.ecsLabelValue;
+        this.ecsType = props.ecsType;
+        this.envId = props.envId;
+        this.machineInfos = props.machineInfos;
+        this.tagIds = props.tagIds;
+        this.type = props.type;
+    }
+    get rosProperties() {
+        return {
+            name: this.name,
+            organizationId: this.organizationId,
+            serviceConnectionId: this.serviceConnectionId,
+            aliyunRegion: this.aliyunRegion,
+            ecsLabelKey: this.ecsLabelKey,
+            ecsLabelValue: this.ecsLabelValue,
+            ecsType: this.ecsType,
+            envId: this.envId,
+            machineInfos: this.machineInfos,
+            tagIds: this.tagIds,
+            type: this.type,
+        };
+    }
+    renderProperties(props) {
+        return rosHostGroupPropsToRosTemplate(props, this.enableResourcePropertyConstraint);
+    }
+}
+exports.RosHostGroup = RosHostGroup;
+/**
+ * The resource type name for this resource class.
+ */
+RosHostGroup.ROS_RESOURCE_TYPE_NAME = "ALIYUN::DEVOPS::HostGroup";
+/**
+ * Determine whether the given properties match those of a `MachineInfosProperty`
+ *
+ * @param properties - the TypeScript properties of a `MachineInfosProperty`
+ *
+ * @returns the result of the validation.
+ */
+function RosHostGroup_MachineInfosPropertyValidator(properties) {
+    if (!ros.canInspect(properties)) {
+        return ros.VALIDATION_SUCCESS;
+    }
+    const errors = new ros.ValidationResults();
+    errors.collect(ros.propertyValidator('instanceName', ros.validateString)(properties.instanceName));
+    errors.collect(ros.propertyValidator('machineSn', ros.requiredValidator)(properties.machineSn));
+    errors.collect(ros.propertyValidator('machineSn', ros.validateString)(properties.machineSn));
+    errors.collect(ros.propertyValidator('ip', ros.validateString)(properties.ip));
+    errors.collect(ros.propertyValidator('aliyunRegionId', ros.validateString)(properties.aliyunRegionId));
+    return errors.wrap('supplied properties not correct for "MachineInfosProperty"');
+}
+/**
+ * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::HostGroup.MachineInfos` resource
+ *
+ * @param properties - the TypeScript properties of a `MachineInfosProperty`
+ *
+ * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::HostGroup.MachineInfos` resource.
+ */
+// @ts-ignore TS6133
+function rosHostGroupMachineInfosPropertyToRosTemplate(properties) {
+    if (!ros.canInspect(properties)) {
+        return properties;
+    }
+    RosHostGroup_MachineInfosPropertyValidator(properties).assertSuccess();
+    return {
+        InstanceName: ros.stringToRosTemplate(properties.instanceName),
+        MachineSn: ros.stringToRosTemplate(properties.machineSn),
+        Ip: ros.stringToRosTemplate(properties.ip),
+        AliyunRegionId: ros.stringToRosTemplate(properties.aliyunRegionId),
+    };
+}
 /**
  * Determine whether the given properties match those of a `RosPipelineProps`
  *
@@ -368,4 +522,4 @@ function rosVariableGroupVariablesPropertyToRosTemplate(properties) {
         value: ros.stringToRosTemplate(properties.value),
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"devops.generated.js","sourceRoot":"","sources":["devops.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 `RosPipeline`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipeline\n */\nexport interface RosPipelineProps {\n\n    /**\n     * @Property content: Pipeline description in YAML format.\n     */\n    readonly content: string | ros.IResolvable;\n\n    /**\n     * @Property name: Pipeline name.\n     */\n    readonly name: string | ros.IResolvable;\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    readonly organizationId: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosPipelineProps`\n *\n * @param properties - the TypeScript properties of a `RosPipelineProps`\n *\n * @returns the result of the validation.\n */\nfunction RosPipelinePropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('content', ros.requiredValidator)(properties.content));\n    errors.collect(ros.propertyValidator('content', ros.validateString)(properties.content));\n    errors.collect(ros.propertyValidator('organizationId', ros.requiredValidator)(properties.organizationId));\n    errors.collect(ros.propertyValidator('organizationId', ros.validateString)(properties.organizationId));\n    errors.collect(ros.propertyValidator('name', ros.requiredValidator)(properties.name));\n    errors.collect(ros.propertyValidator('name', ros.validateString)(properties.name));\n    return errors.wrap('supplied properties not correct for \"RosPipelineProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::Pipeline` resource\n *\n * @param properties - the TypeScript properties of a `RosPipelineProps`\n *\n * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::Pipeline` resource.\n */\n// @ts-ignore TS6133\nfunction rosPipelinePropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosPipelinePropsValidator(properties).assertSuccess();\n    }\n    return {\n      Content: ros.stringToRosTemplate(properties.content),\n      Name: ros.stringToRosTemplate(properties.name),\n      OrganizationId: ros.stringToRosTemplate(properties.organizationId),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::Pipeline`, which is used to create a pipeline. YAML-based pipelines are supported.\n * @Note This class does not contain additional functions, so it is recommended to use the `Pipeline` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipeline\n */\nexport class RosPipeline extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"ALIYUN::DEVOPS::Pipeline\";\n\n    /**\n     * @Attribute PipelineId: Pipeline id.\n     */\n    public readonly attrPipelineId: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property content: Pipeline description in YAML format.\n     */\n    public content: string | ros.IResolvable;\n\n    /**\n     * @Property name: Pipeline name.\n     */\n    public name: string | ros.IResolvable;\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    public organizationId: string | 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: RosPipelineProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosPipeline.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrPipelineId = this.getAtt('PipelineId');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.content = props.content;\n        this.name = props.name;\n        this.organizationId = props.organizationId;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            content: this.content,\n            name: this.name,\n            organizationId: this.organizationId,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosPipelinePropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosPipelineRelations`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerelations\n */\nexport interface RosPipelineRelationsProps {\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    readonly organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.\n     */\n    readonly pipelineId: number | ros.IResolvable;\n\n    /**\n     * @Property relObjectIds: Ids of the associated resource. For now, only variable group ids are supported.\n     */\n    readonly relObjectIds: Array<number | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property relObjectType: Associated resource type. Valid values:\n     * - VARIABLE_GROUP\n     * - OOS_APP_ID\n     * For now, only VARIABLE GROUP is supported.\n     */\n    readonly relObjectType: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosPipelineRelationsProps`\n *\n * @param properties - the TypeScript properties of a `RosPipelineRelationsProps`\n *\n * @returns the result of the validation.\n */\nfunction RosPipelineRelationsPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('relObjectType', ros.requiredValidator)(properties.relObjectType));\n    errors.collect(ros.propertyValidator('relObjectType', ros.validateString)(properties.relObjectType));\n    errors.collect(ros.propertyValidator('relObjectIds', ros.requiredValidator)(properties.relObjectIds));\n    errors.collect(ros.propertyValidator('relObjectIds', ros.listValidator(ros.validateNumber))(properties.relObjectIds));\n    errors.collect(ros.propertyValidator('pipelineId', ros.requiredValidator)(properties.pipelineId));\n    errors.collect(ros.propertyValidator('pipelineId', ros.validateNumber)(properties.pipelineId));\n    errors.collect(ros.propertyValidator('organizationId', ros.requiredValidator)(properties.organizationId));\n    errors.collect(ros.propertyValidator('organizationId', ros.validateString)(properties.organizationId));\n    return errors.wrap('supplied properties not correct for \"RosPipelineRelationsProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::PipelineRelations` resource\n *\n * @param properties - the TypeScript properties of a `RosPipelineRelationsProps`\n *\n * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::PipelineRelations` resource.\n */\n// @ts-ignore TS6133\nfunction rosPipelineRelationsPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosPipelineRelationsPropsValidator(properties).assertSuccess();\n    }\n    return {\n      OrganizationId: ros.stringToRosTemplate(properties.organizationId),\n      PipelineId: ros.numberToRosTemplate(properties.pipelineId),\n      RelObjectIds: ros.listMapper(ros.numberToRosTemplate)(properties.relObjectIds),\n      RelObjectType: ros.stringToRosTemplate(properties.relObjectType),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::PipelineRelations`, which is used to associate resources with a pipeline.\n * @Note This class does not contain additional functions, so it is recommended to use the `PipelineRelations` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerelations\n */\nexport class RosPipelineRelations extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"ALIYUN::DEVOPS::PipelineRelations\";\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    public organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.\n     */\n    public pipelineId: number | ros.IResolvable;\n\n    /**\n     * @Property relObjectIds: Ids of the associated resource. For now, only variable group ids are supported.\n     */\n    public relObjectIds: Array<number | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property relObjectType: Associated resource type. Valid values:\n     * - VARIABLE_GROUP\n     * - OOS_APP_ID\n     * For now, only VARIABLE GROUP is supported.\n     */\n    public relObjectType: string | 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: RosPipelineRelationsProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosPipelineRelations.ROS_RESOURCE_TYPE_NAME, properties: props });\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.organizationId = props.organizationId;\n        this.pipelineId = props.pipelineId;\n        this.relObjectIds = props.relObjectIds;\n        this.relObjectType = props.relObjectType;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            organizationId: this.organizationId,\n            pipelineId: this.pipelineId,\n            relObjectIds: this.relObjectIds,\n            relObjectType: this.relObjectType,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosPipelineRelationsPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosPipelineRun`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerun\n */\nexport interface RosPipelineRunProps {\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    readonly organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.\n     */\n    readonly pipelineId: number | ros.IResolvable;\n\n    /**\n     * @Property params: Pipeline operating parameters. Keys:\n     * - **branchModeBranchs**: Branch mode runs branches.\n     * - **envs**: Running variables.\n     * - **runningBranchs**: Running branches whose key is the warehouse address.\n     * - **runningTags**: Running tags whose key is the warehouse address.\n     */\n    readonly params?: { [key: string]: (any | ros.IResolvable) } | ros.IResolvable;\n\n    /**\n     * @Property sync: Whether to wait synchronously for the result of the pipeline execution. If you select true, the resource will not be created until the pipeline is complete. **Default is false.**\n     * Note: Do not set this option to true when the pipeline has a pause policy configured, as publishing requires manual intervention and synchronization is not appropriate.\n     */\n    readonly sync?: boolean | ros.IResolvable;\n\n    /**\n     * @Property timeout: Maximum wait time for pipeline execution in minutes. This parameter need only be configured if Sync is set to true. **Default is 10.**\n     */\n    readonly timeout?: number | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosPipelineRunProps`\n *\n * @param properties - the TypeScript properties of a `RosPipelineRunProps`\n *\n * @returns the result of the validation.\n */\nfunction RosPipelineRunPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    if(properties.timeout && (typeof properties.timeout) !== 'object') {\n        errors.collect(ros.propertyValidator('timeout', ros.validateRange)({\n            data: properties.timeout,\n            min: 1,\n            max: 120,\n          }));\n    }\n    errors.collect(ros.propertyValidator('timeout', ros.validateNumber)(properties.timeout));\n    errors.collect(ros.propertyValidator('pipelineId', ros.requiredValidator)(properties.pipelineId));\n    errors.collect(ros.propertyValidator('pipelineId', ros.validateNumber)(properties.pipelineId));\n    errors.collect(ros.propertyValidator('params', ros.hashValidator(ros.validateAny))(properties.params));\n    errors.collect(ros.propertyValidator('organizationId', ros.requiredValidator)(properties.organizationId));\n    errors.collect(ros.propertyValidator('organizationId', ros.validateString)(properties.organizationId));\n    errors.collect(ros.propertyValidator('sync', ros.validateBoolean)(properties.sync));\n    return errors.wrap('supplied properties not correct for \"RosPipelineRunProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::PipelineRun` resource\n *\n * @param properties - the TypeScript properties of a `RosPipelineRunProps`\n *\n * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::PipelineRun` resource.\n */\n// @ts-ignore TS6133\nfunction rosPipelineRunPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosPipelineRunPropsValidator(properties).assertSuccess();\n    }\n    return {\n      OrganizationId: ros.stringToRosTemplate(properties.organizationId),\n      PipelineId: ros.numberToRosTemplate(properties.pipelineId),\n      Params: ros.hashMapper(ros.objectToRosTemplate)(properties.params),\n      Sync: ros.booleanToRosTemplate(properties.sync),\n      Timeout: ros.numberToRosTemplate(properties.timeout),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::PipelineRun`, which is used to run a pipeline.\n * @Note This class does not contain additional functions, so it is recommended to use the `PipelineRun` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerun\n */\nexport class RosPipelineRun extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"ALIYUN::DEVOPS::PipelineRun\";\n\n    /**\n     * @Attribute PipelineRunId: Pipeline run id.\n     */\n    public readonly attrPipelineRunId: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    public organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.\n     */\n    public pipelineId: number | ros.IResolvable;\n\n    /**\n     * @Property params: Pipeline operating parameters. Keys:\n     * - **branchModeBranchs**: Branch mode runs branches.\n     * - **envs**: Running variables.\n     * - **runningBranchs**: Running branches whose key is the warehouse address.\n     * - **runningTags**: Running tags whose key is the warehouse address.\n     */\n    public params: { [key: string]: (any | ros.IResolvable) } | ros.IResolvable | undefined;\n\n    /**\n     * @Property sync: Whether to wait synchronously for the result of the pipeline execution. If you select true, the resource will not be created until the pipeline is complete. **Default is false.**\n     * Note: Do not set this option to true when the pipeline has a pause policy configured, as publishing requires manual intervention and synchronization is not appropriate.\n     */\n    public sync: boolean | ros.IResolvable | undefined;\n\n    /**\n     * @Property timeout: Maximum wait time for pipeline execution in minutes. This parameter need only be configured if Sync is set to true. **Default is 10.**\n     */\n    public timeout: number | 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: RosPipelineRunProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosPipelineRun.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrPipelineRunId = this.getAtt('PipelineRunId');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.organizationId = props.organizationId;\n        this.pipelineId = props.pipelineId;\n        this.params = props.params;\n        this.sync = props.sync;\n        this.timeout = props.timeout;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            organizationId: this.organizationId,\n            pipelineId: this.pipelineId,\n            params: this.params,\n            sync: this.sync,\n            timeout: this.timeout,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosPipelineRunPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosVariableGroup`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-variablegroup\n */\nexport interface RosVariableGroupProps {\n\n    /**\n     * @Property name: The name of variable group.\n     */\n    readonly name: string | ros.IResolvable;\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    readonly organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property variables: Variables information.\n     */\n    readonly variables: Array<RosVariableGroup.VariablesProperty | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property description: The description of variable group.\n     */\n    readonly description?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosVariableGroupProps`\n *\n * @param properties - the TypeScript properties of a `RosVariableGroupProps`\n *\n * @returns the result of the validation.\n */\nfunction RosVariableGroupPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('variables', ros.requiredValidator)(properties.variables));\n    errors.collect(ros.propertyValidator('variables', ros.listValidator(RosVariableGroup_VariablesPropertyValidator))(properties.variables));\n    errors.collect(ros.propertyValidator('description', ros.validateString)(properties.description));\n    errors.collect(ros.propertyValidator('organizationId', ros.requiredValidator)(properties.organizationId));\n    errors.collect(ros.propertyValidator('organizationId', ros.validateString)(properties.organizationId));\n    errors.collect(ros.propertyValidator('name', ros.requiredValidator)(properties.name));\n    errors.collect(ros.propertyValidator('name', ros.validateString)(properties.name));\n    return errors.wrap('supplied properties not correct for \"RosVariableGroupProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::VariableGroup` resource\n *\n * @param properties - the TypeScript properties of a `RosVariableGroupProps`\n *\n * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::VariableGroup` resource.\n */\n// @ts-ignore TS6133\nfunction rosVariableGroupPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosVariableGroupPropsValidator(properties).assertSuccess();\n    }\n    return {\n      Name: ros.stringToRosTemplate(properties.name),\n      OrganizationId: ros.stringToRosTemplate(properties.organizationId),\n      Variables: ros.listMapper(rosVariableGroupVariablesPropertyToRosTemplate)(properties.variables),\n      Description: ros.stringToRosTemplate(properties.description),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::VariableGroup`, which is used to create a variable group.\n * @Note This class does not contain additional functions, so it is recommended to use the `VariableGroup` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-variablegroup\n */\nexport class RosVariableGroup extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"ALIYUN::DEVOPS::VariableGroup\";\n\n    /**\n     * @Attribute VariableGroupId: Variable group id.\n     */\n    public readonly attrVariableGroupId: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property name: The name of variable group.\n     */\n    public name: string | ros.IResolvable;\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    public organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property variables: Variables information.\n     */\n    public variables: Array<RosVariableGroup.VariablesProperty | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property description: The description of variable group.\n     */\n    public description: 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: RosVariableGroupProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosVariableGroup.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrVariableGroupId = this.getAtt('VariableGroupId');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.name = props.name;\n        this.organizationId = props.organizationId;\n        this.variables = props.variables;\n        this.description = props.description;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            name: this.name,\n            organizationId: this.organizationId,\n            variables: this.variables,\n            description: this.description,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosVariableGroupPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\nexport namespace RosVariableGroup {\n    /**\n     * @stability external\n     */\n    export interface VariablesProperty {\n        /**\n         * @Property isEncrypted: Encryption or not.\n         */\n        readonly isEncrypted: boolean | ros.IResolvable;\n        /**\n         * @Property name: Name of the variable.\n         */\n        readonly name: string | ros.IResolvable;\n        /**\n         * @Property value: Value of the variable.\n         */\n        readonly value: string | ros.IResolvable;\n    }\n}\n/**\n * Determine whether the given properties match those of a `VariablesProperty`\n *\n * @param properties - the TypeScript properties of a `VariablesProperty`\n *\n * @returns the result of the validation.\n */\nfunction RosVariableGroup_VariablesPropertyValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('isEncrypted', ros.requiredValidator)(properties.isEncrypted));\n    errors.collect(ros.propertyValidator('isEncrypted', ros.validateBoolean)(properties.isEncrypted));\n    errors.collect(ros.propertyValidator('name', ros.requiredValidator)(properties.name));\n    errors.collect(ros.propertyValidator('name', ros.validateString)(properties.name));\n    errors.collect(ros.propertyValidator('value', ros.requiredValidator)(properties.value));\n    errors.collect(ros.propertyValidator('value', ros.validateString)(properties.value));\n    return errors.wrap('supplied properties not correct for \"VariablesProperty\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::VariableGroup.Variables` resource\n *\n * @param properties - the TypeScript properties of a `VariablesProperty`\n *\n * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::VariableGroup.Variables` resource.\n */\n// @ts-ignore TS6133\nfunction rosVariableGroupVariablesPropertyToRosTemplate(properties: any): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    RosVariableGroup_VariablesPropertyValidator(properties).assertSuccess();\n    return {\n      isEncrypted: ros.booleanToRosTemplate(properties.isEncrypted),\n      name: ros.stringToRosTemplate(properties.name),\n      value: ros.stringToRosTemplate(properties.value),\n    };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"devops.generated.js","sourceRoot":"","sources":["devops.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 `RosHostGroup`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-hostgroup\n */\nexport interface RosHostGroupProps {\n\n    /**\n     * @Property name: Host group name.\n     */\n    readonly name: string | ros.IResolvable;\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    readonly organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property serviceConnectionId: Service connection.\n     */\n    readonly serviceConnectionId: number | ros.IResolvable;\n\n    /**\n     * @Property aliyunRegion: The aliyun region.\n     */\n    readonly aliyunRegion?: string | ros.IResolvable;\n\n    /**\n     * @Property ecsLabelKey: The tag key of the ECS.\n     */\n    readonly ecsLabelKey?: string | ros.IResolvable;\n\n    /**\n     * @Property ecsLabelValue: The tag value of the ECS.\n     */\n    readonly ecsLabelValue?: string | ros.IResolvable;\n\n    /**\n     * @Property ecsType: The type of ECS, currently only supports ECS_ALIYUN.\n     */\n    readonly ecsType?: string | ros.IResolvable;\n\n    /**\n     * @Property envId: Environment id.\n     */\n    readonly envId?: string | ros.IResolvable;\n\n    /**\n     * @Property machineInfos: The machine infos\n     */\n    readonly machineInfos?: Array<RosHostGroup.MachineInfosProperty | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property tagIds: The ids of tag.\n     */\n    readonly tagIds?: Array<string | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property type: Host group type, currently only supports ECS.\n     */\n    readonly type?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosHostGroupProps`\n *\n * @param properties - the TypeScript properties of a `RosHostGroupProps`\n *\n * @returns the result of the validation.\n */\nfunction RosHostGroupPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('type', ros.validateString)(properties.type));\n    errors.collect(ros.propertyValidator('serviceConnectionId', ros.requiredValidator)(properties.serviceConnectionId));\n    errors.collect(ros.propertyValidator('serviceConnectionId', ros.validateNumber)(properties.serviceConnectionId));\n    if(properties.tagIds && (Array.isArray(properties.tagIds) || (typeof properties.tagIds) === 'string')) {\n        errors.collect(ros.propertyValidator('tagIds', ros.validateLength)({\n            data: properties.tagIds.length,\n            min: 0,\n            max: 10,\n          }));\n    }\n    errors.collect(ros.propertyValidator('tagIds', ros.listValidator(ros.validateString))(properties.tagIds));\n    errors.collect(ros.propertyValidator('ecsType', ros.validateString)(properties.ecsType));\n    errors.collect(ros.propertyValidator('envId', ros.validateString)(properties.envId));\n    errors.collect(ros.propertyValidator('machineInfos', ros.listValidator(RosHostGroup_MachineInfosPropertyValidator))(properties.machineInfos));\n    errors.collect(ros.propertyValidator('aliyunRegion', ros.validateString)(properties.aliyunRegion));\n    errors.collect(ros.propertyValidator('ecsLabelValue', ros.validateString)(properties.ecsLabelValue));\n    errors.collect(ros.propertyValidator('organizationId', ros.requiredValidator)(properties.organizationId));\n    errors.collect(ros.propertyValidator('organizationId', ros.validateString)(properties.organizationId));\n    errors.collect(ros.propertyValidator('ecsLabelKey', ros.validateString)(properties.ecsLabelKey));\n    errors.collect(ros.propertyValidator('name', ros.requiredValidator)(properties.name));\n    errors.collect(ros.propertyValidator('name', ros.validateString)(properties.name));\n    return errors.wrap('supplied properties not correct for \"RosHostGroupProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::HostGroup` resource\n *\n * @param properties - the TypeScript properties of a `RosHostGroupProps`\n *\n * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::HostGroup` resource.\n */\n// @ts-ignore TS6133\nfunction rosHostGroupPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosHostGroupPropsValidator(properties).assertSuccess();\n    }\n    return {\n      Name: ros.stringToRosTemplate(properties.name),\n      OrganizationId: ros.stringToRosTemplate(properties.organizationId),\n      ServiceConnectionId: ros.numberToRosTemplate(properties.serviceConnectionId),\n      AliyunRegion: ros.stringToRosTemplate(properties.aliyunRegion),\n      EcsLabelKey: ros.stringToRosTemplate(properties.ecsLabelKey),\n      EcsLabelValue: ros.stringToRosTemplate(properties.ecsLabelValue),\n      EcsType: ros.stringToRosTemplate(properties.ecsType),\n      EnvId: ros.stringToRosTemplate(properties.envId),\n      MachineInfos: ros.listMapper(rosHostGroupMachineInfosPropertyToRosTemplate)(properties.machineInfos),\n      TagIds: ros.listMapper(ros.stringToRosTemplate)(properties.tagIds),\n      Type: ros.stringToRosTemplate(properties.type),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::HostGroup`.\n * @Note This class does not contain additional functions, so it is recommended to use the `HostGroup` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-hostgroup\n */\nexport class RosHostGroup extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"ALIYUN::DEVOPS::HostGroup\";\n\n    /**\n     * @Attribute HostGroupId: The id of the host group.\n     */\n    public readonly attrHostGroupId: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property name: Host group name.\n     */\n    public name: string | ros.IResolvable;\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    public organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property serviceConnectionId: Service connection.\n     */\n    public serviceConnectionId: number | ros.IResolvable;\n\n    /**\n     * @Property aliyunRegion: The aliyun region.\n     */\n    public aliyunRegion: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property ecsLabelKey: The tag key of the ECS.\n     */\n    public ecsLabelKey: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property ecsLabelValue: The tag value of the ECS.\n     */\n    public ecsLabelValue: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property ecsType: The type of ECS, currently only supports ECS_ALIYUN.\n     */\n    public ecsType: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property envId: Environment id.\n     */\n    public envId: string | ros.IResolvable | undefined;\n\n    /**\n     * @Property machineInfos: The machine infos\n     */\n    public machineInfos: Array<RosHostGroup.MachineInfosProperty | ros.IResolvable> | ros.IResolvable | undefined;\n\n    /**\n     * @Property tagIds: The ids of tag.\n     */\n    public tagIds: Array<string | ros.IResolvable> | ros.IResolvable | undefined;\n\n    /**\n     * @Property type: Host group type, currently only supports ECS.\n     */\n    public type: 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: RosHostGroupProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosHostGroup.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrHostGroupId = this.getAtt('HostGroupId');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.name = props.name;\n        this.organizationId = props.organizationId;\n        this.serviceConnectionId = props.serviceConnectionId;\n        this.aliyunRegion = props.aliyunRegion;\n        this.ecsLabelKey = props.ecsLabelKey;\n        this.ecsLabelValue = props.ecsLabelValue;\n        this.ecsType = props.ecsType;\n        this.envId = props.envId;\n        this.machineInfos = props.machineInfos;\n        this.tagIds = props.tagIds;\n        this.type = props.type;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            name: this.name,\n            organizationId: this.organizationId,\n            serviceConnectionId: this.serviceConnectionId,\n            aliyunRegion: this.aliyunRegion,\n            ecsLabelKey: this.ecsLabelKey,\n            ecsLabelValue: this.ecsLabelValue,\n            ecsType: this.ecsType,\n            envId: this.envId,\n            machineInfos: this.machineInfos,\n            tagIds: this.tagIds,\n            type: this.type,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosHostGroupPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\nexport namespace RosHostGroup {\n    /**\n     * @stability external\n     */\n    export interface MachineInfosProperty {\n        /**\n         * @Property instanceName: The name of the instance.\n         */\n        readonly instanceName?: string | ros.IResolvable;\n        /**\n         * @Property machineSn: The id of the instance.\n         */\n        readonly machineSn: string | ros.IResolvable;\n        /**\n         * @Property ip: The ip address of the instance.\n         */\n        readonly ip?: string | ros.IResolvable;\n        /**\n         * @Property aliyunRegionId: The aliyun region of the instance.\n         */\n        readonly aliyunRegionId?: string | ros.IResolvable;\n    }\n}\n/**\n * Determine whether the given properties match those of a `MachineInfosProperty`\n *\n * @param properties - the TypeScript properties of a `MachineInfosProperty`\n *\n * @returns the result of the validation.\n */\nfunction RosHostGroup_MachineInfosPropertyValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('instanceName', ros.validateString)(properties.instanceName));\n    errors.collect(ros.propertyValidator('machineSn', ros.requiredValidator)(properties.machineSn));\n    errors.collect(ros.propertyValidator('machineSn', ros.validateString)(properties.machineSn));\n    errors.collect(ros.propertyValidator('ip', ros.validateString)(properties.ip));\n    errors.collect(ros.propertyValidator('aliyunRegionId', ros.validateString)(properties.aliyunRegionId));\n    return errors.wrap('supplied properties not correct for \"MachineInfosProperty\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::HostGroup.MachineInfos` resource\n *\n * @param properties - the TypeScript properties of a `MachineInfosProperty`\n *\n * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::HostGroup.MachineInfos` resource.\n */\n// @ts-ignore TS6133\nfunction rosHostGroupMachineInfosPropertyToRosTemplate(properties: any): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    RosHostGroup_MachineInfosPropertyValidator(properties).assertSuccess();\n    return {\n      InstanceName: ros.stringToRosTemplate(properties.instanceName),\n      MachineSn: ros.stringToRosTemplate(properties.machineSn),\n      Ip: ros.stringToRosTemplate(properties.ip),\n      AliyunRegionId: ros.stringToRosTemplate(properties.aliyunRegionId),\n    };\n}\n\n/**\n * Properties for defining a `RosPipeline`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipeline\n */\nexport interface RosPipelineProps {\n\n    /**\n     * @Property content: Pipeline description in YAML format.\n     */\n    readonly content: string | ros.IResolvable;\n\n    /**\n     * @Property name: Pipeline name.\n     */\n    readonly name: string | ros.IResolvable;\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    readonly organizationId: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosPipelineProps`\n *\n * @param properties - the TypeScript properties of a `RosPipelineProps`\n *\n * @returns the result of the validation.\n */\nfunction RosPipelinePropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('content', ros.requiredValidator)(properties.content));\n    errors.collect(ros.propertyValidator('content', ros.validateString)(properties.content));\n    errors.collect(ros.propertyValidator('organizationId', ros.requiredValidator)(properties.organizationId));\n    errors.collect(ros.propertyValidator('organizationId', ros.validateString)(properties.organizationId));\n    errors.collect(ros.propertyValidator('name', ros.requiredValidator)(properties.name));\n    errors.collect(ros.propertyValidator('name', ros.validateString)(properties.name));\n    return errors.wrap('supplied properties not correct for \"RosPipelineProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::Pipeline` resource\n *\n * @param properties - the TypeScript properties of a `RosPipelineProps`\n *\n * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::Pipeline` resource.\n */\n// @ts-ignore TS6133\nfunction rosPipelinePropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosPipelinePropsValidator(properties).assertSuccess();\n    }\n    return {\n      Content: ros.stringToRosTemplate(properties.content),\n      Name: ros.stringToRosTemplate(properties.name),\n      OrganizationId: ros.stringToRosTemplate(properties.organizationId),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::Pipeline`, which is used to create a pipeline. YAML-based pipelines are supported.\n * @Note This class does not contain additional functions, so it is recommended to use the `Pipeline` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipeline\n */\nexport class RosPipeline extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"ALIYUN::DEVOPS::Pipeline\";\n\n    /**\n     * @Attribute PipelineId: Pipeline id.\n     */\n    public readonly attrPipelineId: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property content: Pipeline description in YAML format.\n     */\n    public content: string | ros.IResolvable;\n\n    /**\n     * @Property name: Pipeline name.\n     */\n    public name: string | ros.IResolvable;\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    public organizationId: string | 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: RosPipelineProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosPipeline.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrPipelineId = this.getAtt('PipelineId');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.content = props.content;\n        this.name = props.name;\n        this.organizationId = props.organizationId;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            content: this.content,\n            name: this.name,\n            organizationId: this.organizationId,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosPipelinePropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosPipelineRelations`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerelations\n */\nexport interface RosPipelineRelationsProps {\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    readonly organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.\n     */\n    readonly pipelineId: number | ros.IResolvable;\n\n    /**\n     * @Property relObjectIds: Ids of the associated resource. For now, only variable group ids are supported.\n     */\n    readonly relObjectIds: Array<number | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property relObjectType: Associated resource type. Valid values:\n     * - VARIABLE_GROUP\n     * - OOS_APP_ID\n     * For now, only VARIABLE GROUP is supported.\n     */\n    readonly relObjectType: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosPipelineRelationsProps`\n *\n * @param properties - the TypeScript properties of a `RosPipelineRelationsProps`\n *\n * @returns the result of the validation.\n */\nfunction RosPipelineRelationsPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('relObjectType', ros.requiredValidator)(properties.relObjectType));\n    errors.collect(ros.propertyValidator('relObjectType', ros.validateString)(properties.relObjectType));\n    errors.collect(ros.propertyValidator('relObjectIds', ros.requiredValidator)(properties.relObjectIds));\n    errors.collect(ros.propertyValidator('relObjectIds', ros.listValidator(ros.validateNumber))(properties.relObjectIds));\n    errors.collect(ros.propertyValidator('pipelineId', ros.requiredValidator)(properties.pipelineId));\n    errors.collect(ros.propertyValidator('pipelineId', ros.validateNumber)(properties.pipelineId));\n    errors.collect(ros.propertyValidator('organizationId', ros.requiredValidator)(properties.organizationId));\n    errors.collect(ros.propertyValidator('organizationId', ros.validateString)(properties.organizationId));\n    return errors.wrap('supplied properties not correct for \"RosPipelineRelationsProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::PipelineRelations` resource\n *\n * @param properties - the TypeScript properties of a `RosPipelineRelationsProps`\n *\n * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::PipelineRelations` resource.\n */\n// @ts-ignore TS6133\nfunction rosPipelineRelationsPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosPipelineRelationsPropsValidator(properties).assertSuccess();\n    }\n    return {\n      OrganizationId: ros.stringToRosTemplate(properties.organizationId),\n      PipelineId: ros.numberToRosTemplate(properties.pipelineId),\n      RelObjectIds: ros.listMapper(ros.numberToRosTemplate)(properties.relObjectIds),\n      RelObjectType: ros.stringToRosTemplate(properties.relObjectType),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::PipelineRelations`, which is used to associate resources with a pipeline.\n * @Note This class does not contain additional functions, so it is recommended to use the `PipelineRelations` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerelations\n */\nexport class RosPipelineRelations extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"ALIYUN::DEVOPS::PipelineRelations\";\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    public organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.\n     */\n    public pipelineId: number | ros.IResolvable;\n\n    /**\n     * @Property relObjectIds: Ids of the associated resource. For now, only variable group ids are supported.\n     */\n    public relObjectIds: Array<number | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property relObjectType: Associated resource type. Valid values:\n     * - VARIABLE_GROUP\n     * - OOS_APP_ID\n     * For now, only VARIABLE GROUP is supported.\n     */\n    public relObjectType: string | 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: RosPipelineRelationsProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosPipelineRelations.ROS_RESOURCE_TYPE_NAME, properties: props });\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.organizationId = props.organizationId;\n        this.pipelineId = props.pipelineId;\n        this.relObjectIds = props.relObjectIds;\n        this.relObjectType = props.relObjectType;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            organizationId: this.organizationId,\n            pipelineId: this.pipelineId,\n            relObjectIds: this.relObjectIds,\n            relObjectType: this.relObjectType,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosPipelineRelationsPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosPipelineRun`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerun\n */\nexport interface RosPipelineRunProps {\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    readonly organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.\n     */\n    readonly pipelineId: number | ros.IResolvable;\n\n    /**\n     * @Property params: Pipeline operating parameters. Keys:\n     * - **branchModeBranchs**: Branch mode runs branches.\n     * - **envs**: Running variables.\n     * - **runningBranchs**: Running branches whose key is the warehouse address.\n     * - **runningTags**: Running tags whose key is the warehouse address.\n     */\n    readonly params?: { [key: string]: (any | ros.IResolvable) } | ros.IResolvable;\n\n    /**\n     * @Property sync: Whether to wait synchronously for the result of the pipeline execution. If you select true, the resource will not be created until the pipeline is complete. **Default is false.**\n     * Note: Do not set this option to true when the pipeline has a pause policy configured, as publishing requires manual intervention and synchronization is not appropriate.\n     */\n    readonly sync?: boolean | ros.IResolvable;\n\n    /**\n     * @Property timeout: Maximum wait time for pipeline execution in minutes. This parameter need only be configured if Sync is set to true. **Default is 10.**\n     */\n    readonly timeout?: number | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosPipelineRunProps`\n *\n * @param properties - the TypeScript properties of a `RosPipelineRunProps`\n *\n * @returns the result of the validation.\n */\nfunction RosPipelineRunPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    if(properties.timeout && (typeof properties.timeout) !== 'object') {\n        errors.collect(ros.propertyValidator('timeout', ros.validateRange)({\n            data: properties.timeout,\n            min: 1,\n            max: 120,\n          }));\n    }\n    errors.collect(ros.propertyValidator('timeout', ros.validateNumber)(properties.timeout));\n    errors.collect(ros.propertyValidator('pipelineId', ros.requiredValidator)(properties.pipelineId));\n    errors.collect(ros.propertyValidator('pipelineId', ros.validateNumber)(properties.pipelineId));\n    errors.collect(ros.propertyValidator('params', ros.hashValidator(ros.validateAny))(properties.params));\n    errors.collect(ros.propertyValidator('organizationId', ros.requiredValidator)(properties.organizationId));\n    errors.collect(ros.propertyValidator('organizationId', ros.validateString)(properties.organizationId));\n    errors.collect(ros.propertyValidator('sync', ros.validateBoolean)(properties.sync));\n    return errors.wrap('supplied properties not correct for \"RosPipelineRunProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::PipelineRun` resource\n *\n * @param properties - the TypeScript properties of a `RosPipelineRunProps`\n *\n * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::PipelineRun` resource.\n */\n// @ts-ignore TS6133\nfunction rosPipelineRunPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosPipelineRunPropsValidator(properties).assertSuccess();\n    }\n    return {\n      OrganizationId: ros.stringToRosTemplate(properties.organizationId),\n      PipelineId: ros.numberToRosTemplate(properties.pipelineId),\n      Params: ros.hashMapper(ros.objectToRosTemplate)(properties.params),\n      Sync: ros.booleanToRosTemplate(properties.sync),\n      Timeout: ros.numberToRosTemplate(properties.timeout),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::PipelineRun`, which is used to run a pipeline.\n * @Note This class does not contain additional functions, so it is recommended to use the `PipelineRun` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerun\n */\nexport class RosPipelineRun extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"ALIYUN::DEVOPS::PipelineRun\";\n\n    /**\n     * @Attribute PipelineRunId: Pipeline run id.\n     */\n    public readonly attrPipelineRunId: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    public organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.\n     */\n    public pipelineId: number | ros.IResolvable;\n\n    /**\n     * @Property params: Pipeline operating parameters. Keys:\n     * - **branchModeBranchs**: Branch mode runs branches.\n     * - **envs**: Running variables.\n     * - **runningBranchs**: Running branches whose key is the warehouse address.\n     * - **runningTags**: Running tags whose key is the warehouse address.\n     */\n    public params: { [key: string]: (any | ros.IResolvable) } | ros.IResolvable | undefined;\n\n    /**\n     * @Property sync: Whether to wait synchronously for the result of the pipeline execution. If you select true, the resource will not be created until the pipeline is complete. **Default is false.**\n     * Note: Do not set this option to true when the pipeline has a pause policy configured, as publishing requires manual intervention and synchronization is not appropriate.\n     */\n    public sync: boolean | ros.IResolvable | undefined;\n\n    /**\n     * @Property timeout: Maximum wait time for pipeline execution in minutes. This parameter need only be configured if Sync is set to true. **Default is 10.**\n     */\n    public timeout: number | 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: RosPipelineRunProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosPipelineRun.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrPipelineRunId = this.getAtt('PipelineRunId');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.organizationId = props.organizationId;\n        this.pipelineId = props.pipelineId;\n        this.params = props.params;\n        this.sync = props.sync;\n        this.timeout = props.timeout;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            organizationId: this.organizationId,\n            pipelineId: this.pipelineId,\n            params: this.params,\n            sync: this.sync,\n            timeout: this.timeout,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosPipelineRunPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\n/**\n * Properties for defining a `RosVariableGroup`.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-variablegroup\n */\nexport interface RosVariableGroupProps {\n\n    /**\n     * @Property name: The name of variable group.\n     */\n    readonly name: string | ros.IResolvable;\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    readonly organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property variables: Variables information.\n     */\n    readonly variables: Array<RosVariableGroup.VariablesProperty | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property description: The description of variable group.\n     */\n    readonly description?: string | ros.IResolvable;\n}\n\n/**\n * Determine whether the given properties match those of a `RosVariableGroupProps`\n *\n * @param properties - the TypeScript properties of a `RosVariableGroupProps`\n *\n * @returns the result of the validation.\n */\nfunction RosVariableGroupPropsValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('variables', ros.requiredValidator)(properties.variables));\n    errors.collect(ros.propertyValidator('variables', ros.listValidator(RosVariableGroup_VariablesPropertyValidator))(properties.variables));\n    errors.collect(ros.propertyValidator('description', ros.validateString)(properties.description));\n    errors.collect(ros.propertyValidator('organizationId', ros.requiredValidator)(properties.organizationId));\n    errors.collect(ros.propertyValidator('organizationId', ros.validateString)(properties.organizationId));\n    errors.collect(ros.propertyValidator('name', ros.requiredValidator)(properties.name));\n    errors.collect(ros.propertyValidator('name', ros.validateString)(properties.name));\n    return errors.wrap('supplied properties not correct for \"RosVariableGroupProps\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::VariableGroup` resource\n *\n * @param properties - the TypeScript properties of a `RosVariableGroupProps`\n *\n * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::VariableGroup` resource.\n */\n// @ts-ignore TS6133\nfunction rosVariableGroupPropsToRosTemplate(properties: any, enableResourcePropertyConstraint: boolean): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    if(enableResourcePropertyConstraint) {\n        RosVariableGroupPropsValidator(properties).assertSuccess();\n    }\n    return {\n      Name: ros.stringToRosTemplate(properties.name),\n      OrganizationId: ros.stringToRosTemplate(properties.organizationId),\n      Variables: ros.listMapper(rosVariableGroupVariablesPropertyToRosTemplate)(properties.variables),\n      Description: ros.stringToRosTemplate(properties.description),\n    };\n}\n\n/**\n * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::VariableGroup`, which is used to create a variable group.\n * @Note This class does not contain additional functions, so it is recommended to use the `VariableGroup` class instead of this class for a more convenient development experience.\n * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-variablegroup\n */\nexport class RosVariableGroup extends ros.RosResource {\n    /**\n     * The resource type name for this resource class.\n     */\n    public static readonly ROS_RESOURCE_TYPE_NAME = \"ALIYUN::DEVOPS::VariableGroup\";\n\n    /**\n     * @Attribute VariableGroupId: Variable group id.\n     */\n    public readonly attrVariableGroupId: ros.IResolvable;\n\n    public enableResourcePropertyConstraint: boolean;\n\n\n    /**\n     * @Property name: The name of variable group.\n     */\n    public name: string | ros.IResolvable;\n\n    /**\n     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.\n     */\n    public organizationId: string | ros.IResolvable;\n\n    /**\n     * @Property variables: Variables information.\n     */\n    public variables: Array<RosVariableGroup.VariablesProperty | ros.IResolvable> | ros.IResolvable;\n\n    /**\n     * @Property description: The description of variable group.\n     */\n    public description: 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: RosVariableGroupProps, enableResourcePropertyConstraint: boolean) {\n        super(scope, id, { type: RosVariableGroup.ROS_RESOURCE_TYPE_NAME, properties: props });\n        this.attrVariableGroupId = this.getAtt('VariableGroupId');\n\n        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;\n        this.name = props.name;\n        this.organizationId = props.organizationId;\n        this.variables = props.variables;\n        this.description = props.description;\n    }\n\n\n    protected get rosProperties(): { [key: string]: any }  {\n        return {\n            name: this.name,\n            organizationId: this.organizationId,\n            variables: this.variables,\n            description: this.description,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return rosVariableGroupPropsToRosTemplate(props, this.enableResourcePropertyConstraint);\n    }\n}\n\nexport namespace RosVariableGroup {\n    /**\n     * @stability external\n     */\n    export interface VariablesProperty {\n        /**\n         * @Property isEncrypted: Encryption or not.\n         */\n        readonly isEncrypted: boolean | ros.IResolvable;\n        /**\n         * @Property name: Name of the variable.\n         */\n        readonly name: string | ros.IResolvable;\n        /**\n         * @Property value: Value of the variable.\n         */\n        readonly value: string | ros.IResolvable;\n    }\n}\n/**\n * Determine whether the given properties match those of a `VariablesProperty`\n *\n * @param properties - the TypeScript properties of a `VariablesProperty`\n *\n * @returns the result of the validation.\n */\nfunction RosVariableGroup_VariablesPropertyValidator(properties: any): ros.ValidationResult {\n    if (!ros.canInspect(properties)) { return ros.VALIDATION_SUCCESS; }\n    const errors = new ros.ValidationResults();\n    errors.collect(ros.propertyValidator('isEncrypted', ros.requiredValidator)(properties.isEncrypted));\n    errors.collect(ros.propertyValidator('isEncrypted', ros.validateBoolean)(properties.isEncrypted));\n    errors.collect(ros.propertyValidator('name', ros.requiredValidator)(properties.name));\n    errors.collect(ros.propertyValidator('name', ros.validateString)(properties.name));\n    errors.collect(ros.propertyValidator('value', ros.requiredValidator)(properties.value));\n    errors.collect(ros.propertyValidator('value', ros.validateString)(properties.value));\n    return errors.wrap('supplied properties not correct for \"VariablesProperty\"');\n}\n\n/**\n * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::VariableGroup.Variables` resource\n *\n * @param properties - the TypeScript properties of a `VariablesProperty`\n *\n * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::VariableGroup.Variables` resource.\n */\n// @ts-ignore TS6133\nfunction rosVariableGroupVariablesPropertyToRosTemplate(properties: any): any {\n    if (!ros.canInspect(properties)) { return properties; }\n    RosVariableGroup_VariablesPropertyValidator(properties).assertSuccess();\n    return {\n      isEncrypted: ros.booleanToRosTemplate(properties.isEncrypted),\n      name: ros.stringToRosTemplate(properties.name),\n      value: ros.stringToRosTemplate(properties.value),\n    };\n}\n"]}

package/lib/hostgroup.d.ts

@@ -0,0 +1,74 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosHostGroup } from './devops.generated';
+export { RosHostGroup as HostGroupProperty };
+/**
+ * Properties for defining a `HostGroup`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-hostgroup
+ */
+export interface HostGroupProps {
+    /**
+     * Property name: Host group name.
+     */
+    readonly name: string | ros.IResolvable;
+    /**
+     * Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.
+     */
+    readonly organizationId: string | ros.IResolvable;
+    /**
+     * Property serviceConnectionId: Service connection.
+     */
+    readonly serviceConnectionId: number | ros.IResolvable;
+    /**
+     * Property aliyunRegion: The aliyun region.
+     */
+    readonly aliyunRegion?: string | ros.IResolvable;
+    /**
+     * Property ecsLabelKey: The tag key of the ECS.
+     */
+    readonly ecsLabelKey?: string | ros.IResolvable;
+    /**
+     * Property ecsLabelValue: The tag value of the ECS.
+     */
+    readonly ecsLabelValue?: string | ros.IResolvable;
+    /**
+     * Property ecsType: The type of ECS, currently only supports ECS_ALIYUN.
+     */
+    readonly ecsType?: string | ros.IResolvable;
+    /**
+     * Property envId: Environment id.
+     */
+    readonly envId?: string | ros.IResolvable;
+    /**
+     * Property machineInfos: The machine infos
+     */
+    readonly machineInfos?: Array<RosHostGroup.MachineInfosProperty | ros.IResolvable> | ros.IResolvable;
+    /**
+     * Property tagIds: The ids of tag.
+     */
+    readonly tagIds?: Array<string | ros.IResolvable> | ros.IResolvable;
+    /**
+     * Property type: Host group type, currently only supports ECS.
+     */
+    readonly type?: string | ros.IResolvable;
+}
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::DEVOPS::HostGroup`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosHostGroup`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-hostgroup
+ */
+export declare class HostGroup extends ros.Resource {
+    protected scope: ros.Construct;
+    protected id: string;
+    protected props: HostGroupProps;
+    protected enableResourcePropertyConstraint: boolean;
+    /**
+     * Attribute HostGroupId: The id of the host group.
+     */
+    readonly attrHostGroupId: ros.IResolvable;
+    /**
+     * Param scope - scope in which this resource is defined
+     * Param id    - scoped id of the resource
+     * Param props - resource properties
+     */
+    constructor(scope: ros.Construct, id: string, props: HostGroupProps, enableResourcePropertyConstraint?: boolean);
+}

package/lib/hostgroup.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostGroup = exports.HostGroupProperty = void 0;
+const ros = require("@alicloud/ros-cdk-core");
+const devops_generated_1 = require("./devops.generated");
+Object.defineProperty(exports, "HostGroupProperty", { enumerable: true, get: function () { return devops_generated_1.RosHostGroup; } });
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::DEVOPS::HostGroup`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosHostGroup`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-hostgroup
+ */
+class HostGroup extends ros.Resource {
+    /**
+     * Param scope - scope in which this resource is defined
+     * Param id    - scoped id of the resource
+     * Param props - resource properties
+     */
+    constructor(scope, id, props, enableResourcePropertyConstraint = true) {
+        super(scope, id);
+        this.scope = scope;
+        this.id = id;
+        this.props = props;
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
+        const rosHostGroup = new devops_generated_1.RosHostGroup(this, id, {
+            type: props.type === undefined || props.type === null ? 'ECS' : props.type,
+            serviceConnectionId: props.serviceConnectionId,
+            tagIds: props.tagIds,
+            ecsType: props.ecsType === undefined || props.ecsType === null ? 'ECS_ALIYUN' : props.ecsType,
+            envId: props.envId,
+            machineInfos: props.machineInfos,
+            aliyunRegion: props.aliyunRegion,
+            ecsLabelValue: props.ecsLabelValue,
+            organizationId: props.organizationId,
+            ecsLabelKey: props.ecsLabelKey,
+            name: props.name,
+        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
+        this.resource = rosHostGroup;
+        this.attrHostGroupId = rosHostGroup.attrHostGroupId;
+    }
+}
+exports.HostGroup = HostGroup;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -1,3 +1,4 @@
+export * from './hostgroup';
 export * from './pipeline';
 export * from './pipelinerelations';
 export * from './pipelinerun';

package/lib/index.js

@@ -10,10 +10,11 @@ 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("./hostgroup"), exports);
 __exportStar(require("./pipeline"), exports);
 __exportStar(require("./pipelinerelations"), exports);
 __exportStar(require("./pipelinerun"), exports);
 __exportStar(require("./variablegroup"), exports);
 // ALIYUN::DEVOPS Resources:
 __exportStar(require("./devops.generated"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw2Q0FBMkI7QUFDM0Isc0RBQW9DO0FBQ3BDLGdEQUE4QjtBQUM5QixrREFBZ0M7QUFFaEMsNEJBQTRCO0FBQzVCLHFEQUFtQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcGlwZWxpbmUnO1xuZXhwb3J0ICogZnJvbSAnLi9waXBlbGluZXJlbGF0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL3BpcGVsaW5lcnVuJztcbmV4cG9ydCAqIGZyb20gJy4vdmFyaWFibGVncm91cCc7XG5cbi8vIEFMSVlVTjo6REVWT1BTIFJlc291cmNlczpcbmV4cG9ydCAqIGZyb20gJy4vZGV2b3BzLmdlbmVyYXRlZCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw4Q0FBNEI7QUFDNUIsNkNBQTJCO0FBQzNCLHNEQUFvQztBQUNwQyxnREFBOEI7QUFDOUIsa0RBQWdDO0FBRWhDLDRCQUE0QjtBQUM1QixxREFBbUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2hvc3Rncm91cCc7XG5leHBvcnQgKiBmcm9tICcuL3BpcGVsaW5lJztcbmV4cG9ydCAqIGZyb20gJy4vcGlwZWxpbmVyZWxhdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9waXBlbGluZXJ1bic7XG5leHBvcnQgKiBmcm9tICcuL3ZhcmlhYmxlZ3JvdXAnO1xuXG4vLyBBTElZVU46OkRFVk9QUyBSZXNvdXJjZXM6XG5leHBvcnQgKiBmcm9tICcuL2Rldm9wcy5nZW5lcmF0ZWQnO1xuIl19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alicloud/ros-cdk-devops",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "Aliyun SDK Copyright (C) Alibaba Cloud Computing All rights reserved. http://www.aliyun.com",
   "author": "ROS Development Team",
   "license": "Apache-2.0",
@@ -44,11 +44,11 @@
     "pack": "npm pack"
   },
   "dependencies": {
-    "@alicloud/ros-cdk-core": "^1.0.6",
+    "@alicloud/ros-cdk-core": "^1.0.27",
     "constructs": "^3.0.4"
   },
   "peerDependencies": {
-    "@alicloud/ros-cdk-core": "^1.0.6",
+    "@alicloud/ros-cdk-core": "^1.0.27",
     "constructs": "^3.0.4"
   }
 }