@alicloud/ros-cdk-devops 1.0.20 → 1.0.22

package/lib/devops.generated.d.ts

@@ -1,6 +1,7 @@
 import * as ros from '@alicloud/ros-cdk-core';
 /**
- * Properties for defining a `ALIYUN::DEVOPS::Pipeline`
+ * Properties for defining a `RosPipeline`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipeline
  */
 export interface RosPipelineProps {
     /**
@@ -17,17 +18,15 @@ export interface RosPipelineProps {
     readonly organizationId: string | ros.IResolvable;
 }
 /**
- * A ROS template type:  `ALIYUN::DEVOPS::Pipeline`
+ * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::Pipeline`ALIYUN::DFS::AccessGroup is used to create a permission group.
+ * @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.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipeline
  */
 export declare class RosPipeline extends ros.RosResource {
     /**
      * The resource type name for this resource class.
      */
     static readonly ROS_RESOURCE_TYPE_NAME = "ALIYUN::DEVOPS::Pipeline";
-    /**
-     * A factory method that creates a new instance of this class from an object
-     * containing the properties of this ROS resource.
-     */
     /**
      * @Attribute PipelineId: Pipeline id.
      */
@@ -46,8 +45,6 @@ export declare class RosPipeline extends ros.RosResource {
      */
     organizationId: string | ros.IResolvable;
     /**
-     * Create a new `ALIYUN::DEVOPS::Pipeline`.
-     *
      * @param scope - scope in which this resource is defined
      * @param id    - scoped id of the resource
      * @param props - resource properties
@@ -63,7 +60,168 @@ export declare class RosPipeline extends ros.RosResource {
     };
 }
 /**
- * Properties for defining a `ALIYUN::DEVOPS::VariableGroup`
+ * Properties for defining a `RosPipelineRelations`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerelations
+ */
+export interface RosPipelineRelationsProps {
+    /**
+     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.
+     */
+    readonly organizationId: string | ros.IResolvable;
+    /**
+     * @Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.
+     */
+    readonly pipelineId: number | ros.IResolvable;
+    /**
+     * @Property relObjectIds: Ids of the associated resource. For now, only variable group ids are supported.
+     */
+    readonly relObjectIds: Array<number | ros.IResolvable> | ros.IResolvable;
+    /**
+     * @Property relObjectType: Associated resource type. Valid values:
+     * - VARIABLE_GROUP
+     * - OOS_APP_ID
+     * For now, only VARIABLE GROUP is supported.
+     */
+    readonly relObjectType: string | ros.IResolvable;
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::PipelineRelations`.
+ * @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.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerelations
+ */
+export declare class RosPipelineRelations extends ros.RosResource {
+    /**
+     * The resource type name for this resource class.
+     */
+    static readonly ROS_RESOURCE_TYPE_NAME = "ALIYUN::DEVOPS::PipelineRelations";
+    enableResourcePropertyConstraint: boolean;
+    /**
+     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.
+     */
+    organizationId: string | ros.IResolvable;
+    /**
+     * @Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.
+     */
+    pipelineId: number | ros.IResolvable;
+    /**
+     * @Property relObjectIds: Ids of the associated resource. For now, only variable group ids are supported.
+     */
+    relObjectIds: Array<number | ros.IResolvable> | ros.IResolvable;
+    /**
+     * @Property relObjectType: Associated resource type. Valid values:
+     * - VARIABLE_GROUP
+     * - OOS_APP_ID
+     * For now, only VARIABLE GROUP is supported.
+     */
+    relObjectType: string | 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: RosPipelineRelationsProps, enableResourcePropertyConstraint: boolean);
+    protected get rosProperties(): {
+        [key: string]: any;
+    };
+    protected renderProperties(props: {
+        [key: string]: any;
+    }): {
+        [key: string]: any;
+    };
+}
+/**
+ * Properties for defining a `RosPipelineRun`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerun
+ */
+export interface RosPipelineRunProps {
+    /**
+     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.
+     */
+    readonly organizationId: string | ros.IResolvable;
+    /**
+     * @Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.
+     */
+    readonly pipelineId: number | ros.IResolvable;
+    /**
+     * @Property params: Pipeline operating parameters. Keys:
+     * - **branchModeBranchs**: Branch mode runs branches.
+     * - **envs**: Running variables.
+     * - **runningBranchs**: Running branches whose key is the warehouse address.
+     * - **runningTags**: Running tags whose key is the warehouse address.
+     */
+    readonly params?: {
+        [key: string]: (any | ros.IResolvable);
+    } | ros.IResolvable;
+    /**
+     * @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.**
+     * 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.
+     */
+    readonly sync?: boolean | ros.IResolvable;
+    /**
+     * @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.**
+     */
+    readonly timeout?: number | ros.IResolvable;
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::PipelineRun`.
+ * @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.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerun
+ */
+export declare class RosPipelineRun extends ros.RosResource {
+    /**
+     * The resource type name for this resource class.
+     */
+    static readonly ROS_RESOURCE_TYPE_NAME = "ALIYUN::DEVOPS::PipelineRun";
+    /**
+     * @Attribute PipelineRunId: Pipeline run id.
+     */
+    readonly attrPipelineRunId: ros.IResolvable;
+    enableResourcePropertyConstraint: boolean;
+    /**
+     * @Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.
+     */
+    organizationId: string | ros.IResolvable;
+    /**
+     * @Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.
+     */
+    pipelineId: number | ros.IResolvable;
+    /**
+     * @Property params: Pipeline operating parameters. Keys:
+     * - **branchModeBranchs**: Branch mode runs branches.
+     * - **envs**: Running variables.
+     * - **runningBranchs**: Running branches whose key is the warehouse address.
+     * - **runningTags**: Running tags whose key is the warehouse address.
+     */
+    params: {
+        [key: string]: (any | ros.IResolvable);
+    } | ros.IResolvable | undefined;
+    /**
+     * @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.**
+     * 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.
+     */
+    sync: boolean | ros.IResolvable | undefined;
+    /**
+     * @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.**
+     */
+    timeout: number | 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: RosPipelineRunProps, enableResourcePropertyConstraint: boolean);
+    protected get rosProperties(): {
+        [key: string]: any;
+    };
+    protected renderProperties(props: {
+        [key: string]: any;
+    }): {
+        [key: string]: any;
+    };
+}
+/**
+ * Properties for defining a `RosVariableGroup`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-variablegroup
  */
 export interface RosVariableGroupProps {
     /**
@@ -84,17 +242,15 @@ export interface RosVariableGroupProps {
     readonly description?: string | ros.IResolvable;
 }
 /**
- * A ROS template type:  `ALIYUN::DEVOPS::VariableGroup`
+ * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::VariableGroup`.
+ * @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.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-variablegroup
  */
 export declare class RosVariableGroup extends ros.RosResource {
     /**
      * The resource type name for this resource class.
      */
     static readonly ROS_RESOURCE_TYPE_NAME = "ALIYUN::DEVOPS::VariableGroup";
-    /**
-     * A factory method that creates a new instance of this class from an object
-     * containing the properties of this ROS resource.
-     */
     /**
      * @Attribute VariableGroupId: Variable group id.
      */
@@ -117,8 +273,6 @@ export declare class RosVariableGroup extends ros.RosResource {
      */
     description: string | ros.IResolvable | undefined;
     /**
-     * Create a new `ALIYUN::DEVOPS::VariableGroup`.
-     *
      * @param scope - scope in which this resource is defined
      * @param id    - scoped id of the resource
      * @param props - resource properties

package/lib/devops.generated.js

@@ -1,7 +1,7 @@
 "use strict";
 // Generated from the AliCloud ROS Resource Specification
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RosVariableGroup = exports.RosPipeline = void 0;
+exports.RosVariableGroup = exports.RosPipelineRun = exports.RosPipelineRelations = exports.RosPipeline = void 0;
 const ros = require("@alicloud/ros-cdk-core");
 /**
  * Determine whether the given properties match those of a `RosPipelineProps`
@@ -45,12 +45,12 @@ function rosPipelinePropsToRosTemplate(properties, enableResourcePropertyConstra
     };
 }
 /**
- * A ROS template type:  `ALIYUN::DEVOPS::Pipeline`
+ * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::Pipeline`ALIYUN::DFS::AccessGroup is used to create a permission group.
+ * @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.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipeline
  */
 class RosPipeline extends ros.RosResource {
     /**
-     * Create a new `ALIYUN::DEVOPS::Pipeline`.
-     *
      * @param scope - scope in which this resource is defined
      * @param id    - scoped id of the resource
      * @param props - resource properties
@@ -79,6 +79,176 @@ exports.RosPipeline = RosPipeline;
  * The resource type name for this resource class.
  */
 RosPipeline.ROS_RESOURCE_TYPE_NAME = "ALIYUN::DEVOPS::Pipeline";
+/**
+ * Determine whether the given properties match those of a `RosPipelineRelationsProps`
+ *
+ * @param properties - the TypeScript properties of a `RosPipelineRelationsProps`
+ *
+ * @returns the result of the validation.
+ */
+function RosPipelineRelationsPropsValidator(properties) {
+    if (!ros.canInspect(properties)) {
+        return ros.VALIDATION_SUCCESS;
+    }
+    const errors = new ros.ValidationResults();
+    errors.collect(ros.propertyValidator('relObjectType', ros.requiredValidator)(properties.relObjectType));
+    errors.collect(ros.propertyValidator('relObjectType', ros.validateString)(properties.relObjectType));
+    errors.collect(ros.propertyValidator('relObjectIds', ros.requiredValidator)(properties.relObjectIds));
+    errors.collect(ros.propertyValidator('relObjectIds', ros.listValidator(ros.validateNumber))(properties.relObjectIds));
+    errors.collect(ros.propertyValidator('pipelineId', ros.requiredValidator)(properties.pipelineId));
+    errors.collect(ros.propertyValidator('pipelineId', ros.validateNumber)(properties.pipelineId));
+    errors.collect(ros.propertyValidator('organizationId', ros.requiredValidator)(properties.organizationId));
+    errors.collect(ros.propertyValidator('organizationId', ros.validateString)(properties.organizationId));
+    return errors.wrap('supplied properties not correct for "RosPipelineRelationsProps"');
+}
+/**
+ * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::PipelineRelations` resource
+ *
+ * @param properties - the TypeScript properties of a `RosPipelineRelationsProps`
+ *
+ * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::PipelineRelations` resource.
+ */
+// @ts-ignore TS6133
+function rosPipelineRelationsPropsToRosTemplate(properties, enableResourcePropertyConstraint) {
+    if (!ros.canInspect(properties)) {
+        return properties;
+    }
+    if (enableResourcePropertyConstraint) {
+        RosPipelineRelationsPropsValidator(properties).assertSuccess();
+    }
+    return {
+        OrganizationId: ros.stringToRosTemplate(properties.organizationId),
+        PipelineId: ros.numberToRosTemplate(properties.pipelineId),
+        RelObjectIds: ros.listMapper(ros.numberToRosTemplate)(properties.relObjectIds),
+        RelObjectType: ros.stringToRosTemplate(properties.relObjectType),
+    };
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::PipelineRelations`.
+ * @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.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerelations
+ */
+class RosPipelineRelations 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: RosPipelineRelations.ROS_RESOURCE_TYPE_NAME, properties: props });
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
+        this.organizationId = props.organizationId;
+        this.pipelineId = props.pipelineId;
+        this.relObjectIds = props.relObjectIds;
+        this.relObjectType = props.relObjectType;
+    }
+    get rosProperties() {
+        return {
+            organizationId: this.organizationId,
+            pipelineId: this.pipelineId,
+            relObjectIds: this.relObjectIds,
+            relObjectType: this.relObjectType,
+        };
+    }
+    renderProperties(props) {
+        return rosPipelineRelationsPropsToRosTemplate(props, this.enableResourcePropertyConstraint);
+    }
+}
+exports.RosPipelineRelations = RosPipelineRelations;
+/**
+ * The resource type name for this resource class.
+ */
+RosPipelineRelations.ROS_RESOURCE_TYPE_NAME = "ALIYUN::DEVOPS::PipelineRelations";
+/**
+ * Determine whether the given properties match those of a `RosPipelineRunProps`
+ *
+ * @param properties - the TypeScript properties of a `RosPipelineRunProps`
+ *
+ * @returns the result of the validation.
+ */
+function RosPipelineRunPropsValidator(properties) {
+    if (!ros.canInspect(properties)) {
+        return ros.VALIDATION_SUCCESS;
+    }
+    const errors = new ros.ValidationResults();
+    if (properties.timeout && (typeof properties.timeout) !== 'object') {
+        errors.collect(ros.propertyValidator('timeout', ros.validateRange)({
+            data: properties.timeout,
+            min: 1,
+            max: 120,
+        }));
+    }
+    errors.collect(ros.propertyValidator('timeout', ros.validateNumber)(properties.timeout));
+    errors.collect(ros.propertyValidator('pipelineId', ros.requiredValidator)(properties.pipelineId));
+    errors.collect(ros.propertyValidator('pipelineId', ros.validateNumber)(properties.pipelineId));
+    errors.collect(ros.propertyValidator('params', ros.hashValidator(ros.validateAny))(properties.params));
+    errors.collect(ros.propertyValidator('organizationId', ros.requiredValidator)(properties.organizationId));
+    errors.collect(ros.propertyValidator('organizationId', ros.validateString)(properties.organizationId));
+    errors.collect(ros.propertyValidator('sync', ros.validateBoolean)(properties.sync));
+    return errors.wrap('supplied properties not correct for "RosPipelineRunProps"');
+}
+/**
+ * Renders the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::PipelineRun` resource
+ *
+ * @param properties - the TypeScript properties of a `RosPipelineRunProps`
+ *
+ * @returns the AliCloud ROS Resource properties of an `ALIYUN::DEVOPS::PipelineRun` resource.
+ */
+// @ts-ignore TS6133
+function rosPipelineRunPropsToRosTemplate(properties, enableResourcePropertyConstraint) {
+    if (!ros.canInspect(properties)) {
+        return properties;
+    }
+    if (enableResourcePropertyConstraint) {
+        RosPipelineRunPropsValidator(properties).assertSuccess();
+    }
+    return {
+        OrganizationId: ros.stringToRosTemplate(properties.organizationId),
+        PipelineId: ros.numberToRosTemplate(properties.pipelineId),
+        Params: ros.hashMapper(ros.objectToRosTemplate)(properties.params),
+        Sync: ros.booleanToRosTemplate(properties.sync),
+        Timeout: ros.numberToRosTemplate(properties.timeout),
+    };
+}
+/**
+ * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::PipelineRun`.
+ * @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.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerun
+ */
+class RosPipelineRun 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: RosPipelineRun.ROS_RESOURCE_TYPE_NAME, properties: props });
+        this.attrPipelineRunId = this.getAtt('PipelineRunId');
+        this.enableResourcePropertyConstraint = enableResourcePropertyConstraint;
+        this.organizationId = props.organizationId;
+        this.pipelineId = props.pipelineId;
+        this.params = props.params;
+        this.sync = props.sync;
+        this.timeout = props.timeout;
+    }
+    get rosProperties() {
+        return {
+            organizationId: this.organizationId,
+            pipelineId: this.pipelineId,
+            params: this.params,
+            sync: this.sync,
+            timeout: this.timeout,
+        };
+    }
+    renderProperties(props) {
+        return rosPipelineRunPropsToRosTemplate(props, this.enableResourcePropertyConstraint);
+    }
+}
+exports.RosPipelineRun = RosPipelineRun;
+/**
+ * The resource type name for this resource class.
+ */
+RosPipelineRun.ROS_RESOURCE_TYPE_NAME = "ALIYUN::DEVOPS::PipelineRun";
 /**
  * Determine whether the given properties match those of a `RosVariableGroupProps`
  *
@@ -123,12 +293,12 @@ function rosVariableGroupPropsToRosTemplate(properties, enableResourcePropertyCo
     };
 }
 /**
- * A ROS template type:  `ALIYUN::DEVOPS::VariableGroup`
+ * This class is a base encapsulation around the ROS resource type `ALIYUN::DEVOPS::VariableGroup`.
+ * @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.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-variablegroup
  */
 class RosVariableGroup extends ros.RosResource {
     /**
-     * Create a new `ALIYUN::DEVOPS::VariableGroup`.
-     *
      * @param scope - scope in which this resource is defined
      * @param id    - scoped id of the resource
      * @param props - resource properties
@@ -198,4 +368,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 `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 * A ROS template type:  `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     * 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 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     * Create a new `ALIYUN::DEVOPS::Pipeline`.\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 `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 * A ROS template type:  `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     * 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 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     * Create a new `ALIYUN::DEVOPS::VariableGroup`.\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 `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`ALIYUN::DFS::AccessGroup is used to create a permission group.\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`.\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`.\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`.\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/index.d.ts

@@ -1,3 +1,5 @@
 export * from './pipeline';
+export * from './pipelinerelations';
+export * from './pipelinerun';
 export * from './variablegroup';
 export * from './devops.generated';

package/lib/index.js

@@ -11,7 +11,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw2Q0FBMkI7QUFDM0Isa0RBQWdDO0FBRWhDLDRCQUE0QjtBQUM1QixxREFBbUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3BpcGVsaW5lJztcbmV4cG9ydCAqIGZyb20gJy4vdmFyaWFibGVncm91cCc7XG5cbi8vIEFMSVlVTjo6REVWT1BTIFJlc291cmNlczpcbmV4cG9ydCAqIGZyb20gJy4vZGV2b3BzLmdlbmVyYXRlZCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw2Q0FBMkI7QUFDM0Isc0RBQW9DO0FBQ3BDLGdEQUE4QjtBQUM5QixrREFBZ0M7QUFFaEMsNEJBQTRCO0FBQzVCLHFEQUFtQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcGlwZWxpbmUnO1xuZXhwb3J0ICogZnJvbSAnLi9waXBlbGluZXJlbGF0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL3BpcGVsaW5lcnVuJztcbmV4cG9ydCAqIGZyb20gJy4vdmFyaWFibGVncm91cCc7XG5cbi8vIEFMSVlVTjo6REVWT1BTIFJlc291cmNlczpcbmV4cG9ydCAqIGZyb20gJy4vZGV2b3BzLmdlbmVyYXRlZCc7XG4iXX0=

package/lib/pipeline.d.ts

@@ -2,7 +2,8 @@ import * as ros from '@alicloud/ros-cdk-core';
 import { RosPipeline } from './devops.generated';
 export { RosPipeline as PipelineProperty };
 /**
- * Properties for defining a `ALIYUN::DEVOPS::Pipeline`
+ * Properties for defining a `Pipeline`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipeline
  */
 export interface PipelineProps {
     /**
@@ -19,20 +20,16 @@ export interface PipelineProps {
     readonly organizationId: string | ros.IResolvable;
 }
 /**
- * A ROS resource type:  `ALIYUN::DEVOPS::Pipeline`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::DEVOPS::Pipeline`ALIYUN::DFS::AccessGroup is used to create a permission group.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosPipeline`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipeline
  */
 export declare class Pipeline 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 PipelineId: Pipeline id.
      */
     readonly attrPipelineId: ros.IResolvable;
     /**
-     * Create a new `ALIYUN::DEVOPS::Pipeline`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties

package/lib/pipeline.js

@@ -5,12 +5,12 @@ const ros = require("@alicloud/ros-cdk-core");
 const devops_generated_1 = require("./devops.generated");
 Object.defineProperty(exports, "PipelineProperty", { enumerable: true, get: function () { return devops_generated_1.RosPipeline; } });
 /**
- * A ROS resource type:  `ALIYUN::DEVOPS::Pipeline`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::DEVOPS::Pipeline`ALIYUN::DFS::AccessGroup is used to create a permission group.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosPipeline`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipeline
  */
 class Pipeline extends ros.Resource {
     /**
-     * Create a new `ALIYUN::DEVOPS::Pipeline`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties
@@ -27,4 +27,4 @@ class Pipeline extends ros.Resource {
     }
 }
 exports.Pipeline = Pipeline;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/pipelinerelations.d.ts

@@ -0,0 +1,41 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosPipelineRelations } from './devops.generated';
+export { RosPipelineRelations as PipelineRelationsProperty };
+/**
+ * Properties for defining a `PipelineRelations`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerelations
+ */
+export interface PipelineRelationsProps {
+    /**
+     * Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.
+     */
+    readonly organizationId: string | ros.IResolvable;
+    /**
+     * Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.
+     */
+    readonly pipelineId: number | ros.IResolvable;
+    /**
+     * Property relObjectIds: Ids of the associated resource. For now, only variable group ids are supported.
+     */
+    readonly relObjectIds: Array<number | ros.IResolvable> | ros.IResolvable;
+    /**
+     * Property relObjectType: Associated resource type. Valid values:
+     * - VARIABLE_GROUP
+     * - OOS_APP_ID
+     * For now, only VARIABLE GROUP is supported.
+     */
+    readonly relObjectType: string | ros.IResolvable;
+}
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::DEVOPS::PipelineRelations`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosPipelineRelations`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerelations
+ */
+export declare class PipelineRelations 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: ros.Construct, id: string, props: PipelineRelationsProps, enableResourcePropertyConstraint?: boolean);
+}

package/lib/pipelinerelations.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineRelations = exports.PipelineRelationsProperty = void 0;
+const ros = require("@alicloud/ros-cdk-core");
+const devops_generated_1 = require("./devops.generated");
+Object.defineProperty(exports, "PipelineRelationsProperty", { enumerable: true, get: function () { return devops_generated_1.RosPipelineRelations; } });
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::DEVOPS::PipelineRelations`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosPipelineRelations`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerelations
+ */
+class PipelineRelations 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);
+        const rosPipelineRelations = new devops_generated_1.RosPipelineRelations(this, id, {
+            relObjectType: props.relObjectType,
+            relObjectIds: props.relObjectIds,
+            pipelineId: props.pipelineId,
+            organizationId: props.organizationId,
+        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
+        this.resource = rosPipelineRelations;
+    }
+}
+exports.PipelineRelations = PipelineRelations;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/pipelinerun.d.ts

@@ -0,0 +1,53 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { RosPipelineRun } from './devops.generated';
+export { RosPipelineRun as PipelineRunProperty };
+/**
+ * Properties for defining a `PipelineRun`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerun
+ */
+export interface PipelineRunProps {
+    /**
+     * Property organizationId: Corporate identity, also known as enterprise id, can obtain in cloud effect access links.
+     */
+    readonly organizationId: string | ros.IResolvable;
+    /**
+     * Property pipelineId: The pipeline ID, which can be obtained from the pipeline link.
+     */
+    readonly pipelineId: number | ros.IResolvable;
+    /**
+     * Property params: Pipeline operating parameters. Keys:
+     * - **branchModeBranchs**: Branch mode runs branches.
+     * - **envs**: Running variables.
+     * - **runningBranchs**: Running branches whose key is the warehouse address.
+     * - **runningTags**: Running tags whose key is the warehouse address.
+     */
+    readonly params?: {
+        [key: string]: (any | ros.IResolvable);
+    } | ros.IResolvable;
+    /**
+     * 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.**
+     * 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.
+     */
+    readonly sync?: boolean | ros.IResolvable;
+    /**
+     * 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.**
+     */
+    readonly timeout?: number | ros.IResolvable;
+}
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::DEVOPS::PipelineRun`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosPipelineRun`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerun
+ */
+export declare class PipelineRun extends ros.Resource {
+    /**
+     * Attribute PipelineRunId: Pipeline run id.
+     */
+    readonly attrPipelineRunId: 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: PipelineRunProps, enableResourcePropertyConstraint?: boolean);
+}

package/lib/pipelinerun.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineRun = exports.PipelineRunProperty = void 0;
+const ros = require("@alicloud/ros-cdk-core");
+const devops_generated_1 = require("./devops.generated");
+Object.defineProperty(exports, "PipelineRunProperty", { enumerable: true, get: function () { return devops_generated_1.RosPipelineRun; } });
+/**
+ * This class encapsulates and extends the ROS resource type `ALIYUN::DEVOPS::PipelineRun`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosPipelineRun`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-pipelinerun
+ */
+class PipelineRun 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);
+        const rosPipelineRun = new devops_generated_1.RosPipelineRun(this, id, {
+            timeout: props.timeout === undefined || props.timeout === null ? 10 : props.timeout,
+            pipelineId: props.pipelineId,
+            params: props.params,
+            organizationId: props.organizationId,
+            sync: props.sync === undefined || props.sync === null ? false : props.sync,
+        }, enableResourcePropertyConstraint && this.stack.enableResourcePropertyConstraint);
+        this.resource = rosPipelineRun;
+        this.attrPipelineRunId = rosPipelineRun.attrPipelineRunId;
+    }
+}
+exports.PipelineRun = PipelineRun;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/variablegroup.d.ts

@@ -2,7 +2,8 @@ import * as ros from '@alicloud/ros-cdk-core';
 import { RosVariableGroup } from './devops.generated';
 export { RosVariableGroup as VariableGroupProperty };
 /**
- * Properties for defining a `ALIYUN::DEVOPS::VariableGroup`
+ * Properties for defining a `VariableGroup`.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-variablegroup
  */
 export interface VariableGroupProps {
     /**
@@ -23,20 +24,16 @@ export interface VariableGroupProps {
     readonly description?: string | ros.IResolvable;
 }
 /**
- * A ROS resource type:  `ALIYUN::DEVOPS::VariableGroup`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::DEVOPS::VariableGroup`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosVariableGroup`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-variablegroup
  */
 export declare class VariableGroup 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 VariableGroupId: Variable group id.
      */
     readonly attrVariableGroupId: ros.IResolvable;
     /**
-     * Create a new `ALIYUN::DEVOPS::VariableGroup`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties

package/lib/variablegroup.js

@@ -5,12 +5,12 @@ const ros = require("@alicloud/ros-cdk-core");
 const devops_generated_1 = require("./devops.generated");
 Object.defineProperty(exports, "VariableGroupProperty", { enumerable: true, get: function () { return devops_generated_1.RosVariableGroup; } });
 /**
- * A ROS resource type:  `ALIYUN::DEVOPS::VariableGroup`
+ * This class encapsulates and extends the ROS resource type `ALIYUN::DEVOPS::VariableGroup`.
+ * @Note This class may have some new functions to facilitate development, so it is recommended to use this class instead of `RosVariableGroup`for a more convenient development experience.
+ * See https://www.alibabacloud.com/help/ros/developer-reference/aliyun-devops-variablegroup
  */
 class VariableGroup extends ros.Resource {
     /**
-     * Create a new `ALIYUN::DEVOPS::VariableGroup`.
-     *
      * Param scope - scope in which this resource is defined
      * Param id    - scoped id of the resource
      * Param props - resource properties
@@ -28,4 +28,4 @@ class VariableGroup extends ros.Resource {
     }
 }
 exports.VariableGroup = VariableGroup;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

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