projen 0.79.4__py3-none-any.whl → 0.98.25__py3-none-any.whl

projen/github/__init__.py

@@ -1,3 +1,6 @@
+from pkgutil import extend_path
+__path__ = extend_path(__path__, __name__)
+
 import abc
 import builtins
 import datetime
@@ -8,7 +11,22 @@ import jsii
 import publication
 import typing_extensions
 
-from typeguard import check_type
+import typeguard
+from importlib.metadata import version as _metadata_package_version
+TYPEGUARD_MAJOR_VERSION = int(_metadata_package_version('typeguard').split('.')[0])
+
+def check_type(argname: str, value: object, expected_type: typing.Any) -> typing.Any:
+    if TYPEGUARD_MAJOR_VERSION <= 2:
+        return typeguard.check_type(argname=argname, value=value, expected_type=expected_type) # type:ignore
+    else:
+        if isinstance(value, jsii._reference_map.InterfaceDynamicProxy): # pyright: ignore [reportAttributeAccessIssue]
+           pass
+        else:
+            if TYPEGUARD_MAJOR_VERSION == 3:
+                typeguard.config.collection_check_strategy = typeguard.CollectionCheckStrategy.ALL_ITEMS # type:ignore
+                typeguard.check_type(value=value, expected_type=expected_type) # type:ignore
+            else:
+                typeguard.check_type(value=value, expected_type=expected_type, collection_check_strategy=typeguard.CollectionCheckStrategy.ALL_ITEMS) # type:ignore
 
 from .._jsii import *
 
@@ -19,6 +37,7 @@ from .. import (
     Gitpod as _Gitpod_5d9b9d87,
     GroupRunnerOptions as _GroupRunnerOptions_148c59c1,
     IgnoreFileOptions as _IgnoreFileOptions_86c48b91,
+    JsonFile as _JsonFile_fa8164db,
     LoggerOptions as _LoggerOptions_eb0f6309,
     Project as _Project_57d89203,
     ProjectOptions as _ProjectOptions_0d5b93c6,
@@ -269,7 +288,13 @@ class AutoMerge(
     metaclass=jsii.JSIIMeta,
     jsii_type="projen.github.AutoMerge",
 ):
-    '''(experimental) Sets up mergify to merging approved pull requests.
+    '''(experimental) Automatically merge Pull Requests using Mergify.
+
+    .. epigraph::
+
+       [!NOTE]
+       GitHub now natively provides the same features, so you don't need Mergify
+       anymore. See ``GitHubOptions.mergeQueue`` and ``MergeQueueOptions.autoQueue``.
 
     If ``buildJob`` is specified, the specified GitHub workflow job ID is required
     to succeed in order for the PR to be merged.
@@ -277,6 +302,7 @@ class AutoMerge(
     ``approvedReviews`` specified the number of code review approvals required for
     the PR to be merged.
 
+    :see: https://mergify.com/
     :stability: experimental
     '''
 
@@ -436,6 +462,219 @@ class AutoMergeOptions:
         )
 
 
+class AutoQueue(
+    _Component_2b0ad27f,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="projen.github.AutoQueue",
+):
+    '''(experimental) Automatically add pull requests to the merge queue PRs will be merged once they pass required checks.
+
+    :stability: experimental
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.IConstruct,
+        *,
+        allowed_usernames: typing.Optional[typing.Sequence[builtins.str]] = None,
+        labels: typing.Optional[typing.Sequence[builtins.str]] = None,
+        merge_method: typing.Optional["MergeMethod"] = None,
+        projen_credentials: typing.Optional["GithubCredentials"] = None,
+        runs_on: typing.Optional[typing.Sequence[builtins.str]] = None,
+        target_branches: typing.Optional[typing.Sequence[builtins.str]] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param allowed_usernames: (experimental) Only pull requests authored by these Github usernames will have auto-queue enabled. Default: - pull requests from all users are eligible for auto-queuing
+        :param labels: (experimental) Only pull requests with one of this labels will have auto-queue enabled. Default: - all pull requests are eligible for auto-queueing
+        :param merge_method: (experimental) The method used to add the PR to the merge queue Any branch protection rules must allow this merge method. Default: MergeMethod.SQUASH
+        :param projen_credentials: (experimental) Choose a method for authenticating with GitHub to enable auto-queue on pull requests. The workflow cannot use a default github token. Queuing a PR with the default token will not trigger any merge queue workflows, which results in the PR just not getting merged at all. Default: - uses credentials from the GitHub component
+        :param runs_on: (experimental) Github Runner selection labels. Default: ["ubuntu-latest"]
+        :param target_branches: (experimental) The branch names that we should auto-queue for. This set of branches should be a subset of ``MergeQueueOptions.targetBranches``. Be sure not to enable ``autoQueue`` for branches that don't have branch rules with merge requirements set up, otherwise new PRs will be merged immediately after creating without a chance for review. Automatically merging a set of Stacked PRs If you set this to ``['main']`` you can automatically merge a set of Stacked PRs in the right order. It works like this: - Create PR #1 from branch ``a``, targeting ``main``. - Create PR #2 from branch ``b``, targeting branch ``a``. - Create PR #3 from branch ``c``, targeting branch ``b``. Initially, PR #1 will be set to auto-merge, PRs #2 and #3 will not. Once PR #1 passes all of its requirements it will merge. That will delete branch ``a`` and change the target branch of PR #2 change to ``main``. At that point, auto-queueing will switch on for PR #2 and it gets merged, etc. .. epigraph:: [!IMPORTANT] This component will never disable AutoMerge, only enable it. So if a PR is initially targeted at one of the branches in this list, and then subsequently retargeted to another branch, *AutoMerge is not automatically turned off*.
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__d1a61bf6b1de263219ae71fb7c610ca1482abce41103e188b62ebe38e0314b58)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+        options = AutoQueueOptions(
+            allowed_usernames=allowed_usernames,
+            labels=labels,
+            merge_method=merge_method,
+            projen_credentials=projen_credentials,
+            runs_on=runs_on,
+            target_branches=target_branches,
+        )
+
+        jsii.create(self.__class__, self, [scope, options])
+
+
+@jsii.data_type(
+    jsii_type="projen.github.AutoQueueOptions",
+    jsii_struct_bases=[],
+    name_mapping={
+        "allowed_usernames": "allowedUsernames",
+        "labels": "labels",
+        "merge_method": "mergeMethod",
+        "projen_credentials": "projenCredentials",
+        "runs_on": "runsOn",
+        "target_branches": "targetBranches",
+    },
+)
+class AutoQueueOptions:
+    def __init__(
+        self,
+        *,
+        allowed_usernames: typing.Optional[typing.Sequence[builtins.str]] = None,
+        labels: typing.Optional[typing.Sequence[builtins.str]] = None,
+        merge_method: typing.Optional["MergeMethod"] = None,
+        projen_credentials: typing.Optional["GithubCredentials"] = None,
+        runs_on: typing.Optional[typing.Sequence[builtins.str]] = None,
+        target_branches: typing.Optional[typing.Sequence[builtins.str]] = None,
+    ) -> None:
+        '''(experimental) Options for 'AutoQueue'.
+
+        :param allowed_usernames: (experimental) Only pull requests authored by these Github usernames will have auto-queue enabled. Default: - pull requests from all users are eligible for auto-queuing
+        :param labels: (experimental) Only pull requests with one of this labels will have auto-queue enabled. Default: - all pull requests are eligible for auto-queueing
+        :param merge_method: (experimental) The method used to add the PR to the merge queue Any branch protection rules must allow this merge method. Default: MergeMethod.SQUASH
+        :param projen_credentials: (experimental) Choose a method for authenticating with GitHub to enable auto-queue on pull requests. The workflow cannot use a default github token. Queuing a PR with the default token will not trigger any merge queue workflows, which results in the PR just not getting merged at all. Default: - uses credentials from the GitHub component
+        :param runs_on: (experimental) Github Runner selection labels. Default: ["ubuntu-latest"]
+        :param target_branches: (experimental) The branch names that we should auto-queue for. This set of branches should be a subset of ``MergeQueueOptions.targetBranches``. Be sure not to enable ``autoQueue`` for branches that don't have branch rules with merge requirements set up, otherwise new PRs will be merged immediately after creating without a chance for review. Automatically merging a set of Stacked PRs If you set this to ``['main']`` you can automatically merge a set of Stacked PRs in the right order. It works like this: - Create PR #1 from branch ``a``, targeting ``main``. - Create PR #2 from branch ``b``, targeting branch ``a``. - Create PR #3 from branch ``c``, targeting branch ``b``. Initially, PR #1 will be set to auto-merge, PRs #2 and #3 will not. Once PR #1 passes all of its requirements it will merge. That will delete branch ``a`` and change the target branch of PR #2 change to ``main``. At that point, auto-queueing will switch on for PR #2 and it gets merged, etc. .. epigraph:: [!IMPORTANT] This component will never disable AutoMerge, only enable it. So if a PR is initially targeted at one of the branches in this list, and then subsequently retargeted to another branch, *AutoMerge is not automatically turned off*.
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__f138097d225158d553505a4839bf1c114c4a0e41bc55b7d24234176015382a5d)
+            check_type(argname="argument allowed_usernames", value=allowed_usernames, expected_type=type_hints["allowed_usernames"])
+            check_type(argname="argument labels", value=labels, expected_type=type_hints["labels"])
+            check_type(argname="argument merge_method", value=merge_method, expected_type=type_hints["merge_method"])
+            check_type(argname="argument projen_credentials", value=projen_credentials, expected_type=type_hints["projen_credentials"])
+            check_type(argname="argument runs_on", value=runs_on, expected_type=type_hints["runs_on"])
+            check_type(argname="argument target_branches", value=target_branches, expected_type=type_hints["target_branches"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if allowed_usernames is not None:
+            self._values["allowed_usernames"] = allowed_usernames
+        if labels is not None:
+            self._values["labels"] = labels
+        if merge_method is not None:
+            self._values["merge_method"] = merge_method
+        if projen_credentials is not None:
+            self._values["projen_credentials"] = projen_credentials
+        if runs_on is not None:
+            self._values["runs_on"] = runs_on
+        if target_branches is not None:
+            self._values["target_branches"] = target_branches
+
+    @builtins.property
+    def allowed_usernames(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) Only pull requests authored by these Github usernames will have auto-queue enabled.
+
+        :default: - pull requests from all users are eligible for auto-queuing
+
+        :stability: experimental
+        '''
+        result = self._values.get("allowed_usernames")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def labels(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) Only pull requests with one of this labels will have auto-queue enabled.
+
+        :default: - all pull requests are eligible for auto-queueing
+
+        :stability: experimental
+        '''
+        result = self._values.get("labels")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def merge_method(self) -> typing.Optional["MergeMethod"]:
+        '''(experimental) The method used to add the PR to the merge queue Any branch protection rules must allow this merge method.
+
+        :default: MergeMethod.SQUASH
+
+        :stability: experimental
+        '''
+        result = self._values.get("merge_method")
+        return typing.cast(typing.Optional["MergeMethod"], result)
+
+    @builtins.property
+    def projen_credentials(self) -> typing.Optional["GithubCredentials"]:
+        '''(experimental) Choose a method for authenticating with GitHub to enable auto-queue on pull requests.
+
+        The workflow cannot use a default github token. Queuing a PR
+        with the default token will not trigger any merge queue workflows,
+        which results in the PR just not getting merged at all.
+
+        :default: - uses credentials from the GitHub component
+
+        :see: https://projen.io/docs/integrations/github/
+        :stability: experimental
+        '''
+        result = self._values.get("projen_credentials")
+        return typing.cast(typing.Optional["GithubCredentials"], result)
+
+    @builtins.property
+    def runs_on(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) Github Runner selection labels.
+
+        :default: ["ubuntu-latest"]
+
+        :stability: experimental
+        '''
+        result = self._values.get("runs_on")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def target_branches(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) The branch names that we should auto-queue for.
+
+        This set of branches should be a subset of ``MergeQueueOptions.targetBranches``.
+
+        Be sure not to enable ``autoQueue`` for branches that don't have branch rules
+        with merge requirements set up, otherwise new PRs will be merged
+        immediately after creating without a chance for review.
+
+
+        Automatically merging a set of Stacked PRs
+
+        If you set this to ``['main']`` you can automatically merge a set of Stacked PRs
+        in the right order. It works like this:
+
+        - Create PR #1 from branch ``a``, targeting ``main``.
+        - Create PR #2 from branch ``b``, targeting branch ``a``.
+        - Create PR #3 from branch ``c``, targeting branch ``b``.
+
+        Initially, PR #1 will be set to auto-merge, PRs #2 and #3 will not.
+
+        Once PR #1 passes all of its requirements it will merge. That will delete
+        branch ``a`` and change  the target branch of PR #2 change to ``main``. At that
+        point, auto-queueing will switch on for PR #2 and it gets merged, etc.
+        .. epigraph::
+
+           [!IMPORTANT]
+           This component will never disable AutoMerge, only enable it. So if a PR is
+           initially targeted at one of the branches in this list, and then
+           subsequently retargeted to another branch, *AutoMerge is not
+           automatically turned off*.
+
+        :stability: experimental
+        '''
+        result = self._values.get("target_branches")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "AutoQueueOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="projen.github.CheckoutOptions",
     jsii_struct_bases=[_JobStepConfiguration_9caff420],
@@ -444,6 +683,7 @@ class AutoMergeOptions:
         "id": "id",
         "if_": "if",
         "name": "name",
+        "shell": "shell",
         "working_directory": "workingDirectory",
         "continue_on_error": "continueOnError",
         "timeout_minutes": "timeoutMinutes",
@@ -458,6 +698,7 @@ class CheckoutOptions(_JobStepConfiguration_9caff420):
         id: typing.Optional[builtins.str] = None,
         if_: typing.Optional[builtins.str] = None,
         name: typing.Optional[builtins.str] = None,
+        shell: typing.Optional[builtins.str] = None,
         working_directory: typing.Optional[builtins.str] = None,
         continue_on_error: typing.Optional[builtins.bool] = None,
         timeout_minutes: typing.Optional[jsii.Number] = None,
@@ -468,6 +709,7 @@ class CheckoutOptions(_JobStepConfiguration_9caff420):
         :param id: (experimental) A unique identifier for the step. You can use the id to reference the step in contexts.
         :param if_: (experimental) You can use the if conditional to prevent a job from running unless a condition is met. You can use any supported context and expression to create a conditional.
         :param name: (experimental) A name for your step to display on GitHub.
+        :param shell: (experimental) Overrides the default shell settings in the runner's operating system and the job's default. Refer to GitHub documentation for allowed values.
         :param working_directory: (experimental) Specifies a working directory for a step. Overrides a job's working directory.
         :param continue_on_error: (experimental) Prevents a job from failing when a step fails. Set to true to allow a job to pass when this step fails.
         :param timeout_minutes: (experimental) The maximum number of minutes to run the step before killing the process.
@@ -483,6 +725,7 @@ class CheckoutOptions(_JobStepConfiguration_9caff420):
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
             check_type(argname="argument if_", value=if_, expected_type=type_hints["if_"])
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument shell", value=shell, expected_type=type_hints["shell"])
             check_type(argname="argument working_directory", value=working_directory, expected_type=type_hints["working_directory"])
             check_type(argname="argument continue_on_error", value=continue_on_error, expected_type=type_hints["continue_on_error"])
             check_type(argname="argument timeout_minutes", value=timeout_minutes, expected_type=type_hints["timeout_minutes"])
@@ -496,6 +739,8 @@ class CheckoutOptions(_JobStepConfiguration_9caff420):
             self._values["if_"] = if_
         if name is not None:
             self._values["name"] = name
+        if shell is not None:
+            self._values["shell"] = shell
         if working_directory is not None:
             self._values["working_directory"] = working_directory
         if continue_on_error is not None:
@@ -549,6 +794,18 @@ class CheckoutOptions(_JobStepConfiguration_9caff420):
         result = self._values.get("name")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def shell(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Overrides the default shell settings in the runner's operating system and the job's default.
+
+        Refer to GitHub documentation for allowed values.
+
+        :see: https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsshell
+        :stability: experimental
+        '''
+        result = self._values.get("shell")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def working_directory(self) -> typing.Optional[builtins.str]:
         '''(experimental) Specifies a working directory for a step.
@@ -608,6 +865,7 @@ class CheckoutOptions(_JobStepConfiguration_9caff420):
     name_mapping={
         "fetch_depth": "fetchDepth",
         "lfs": "lfs",
+        "path": "path",
         "ref": "ref",
         "repository": "repository",
         "token": "token",
@@ -619,6 +877,7 @@ class CheckoutWith:
         *,
         fetch_depth: typing.Optional[jsii.Number] = None,
         lfs: typing.Optional[builtins.bool] = None,
+        path: typing.Optional[builtins.str] = None,
         ref: typing.Optional[builtins.str] = None,
         repository: typing.Optional[builtins.str] = None,
         token: typing.Optional[builtins.str] = None,
@@ -627,6 +886,7 @@ class CheckoutWith:
 
         :param fetch_depth: (experimental) Number of commits to fetch. 0 indicates all history for all branches and tags. Default: 1
         :param lfs: (experimental) Whether LFS is enabled for the GitHub repository. Default: false
+        :param path: (experimental) Relative path under $GITHUB_WORKSPACE to place the repository. Default: - $GITHUB_WORKSPACE
         :param ref: (experimental) Branch or tag name. Default: - the default branch is implicitly used
         :param repository: (experimental) The repository (owner/repo) to use. Default: - the default repository is implicitly used
         :param token: (experimental) A GitHub token to use when checking out the repository. If the intent is to push changes back to the branch, then you must use a PAT with ``repo`` (and possibly ``workflows``) permissions. Default: - the default GITHUB_TOKEN is implicitly used
@@ -637,6 +897,7 @@ class CheckoutWith:
             type_hints = typing.get_type_hints(_typecheckingstub__57379070911f0df36ef38a23c138780de73f270c4e64ea8e6b7f4f128eb8ac6a)
             check_type(argname="argument fetch_depth", value=fetch_depth, expected_type=type_hints["fetch_depth"])
             check_type(argname="argument lfs", value=lfs, expected_type=type_hints["lfs"])
+            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
             check_type(argname="argument ref", value=ref, expected_type=type_hints["ref"])
             check_type(argname="argument repository", value=repository, expected_type=type_hints["repository"])
             check_type(argname="argument token", value=token, expected_type=type_hints["token"])
@@ -645,6 +906,8 @@ class CheckoutWith:
             self._values["fetch_depth"] = fetch_depth
         if lfs is not None:
             self._values["lfs"] = lfs
+        if path is not None:
+            self._values["path"] = path
         if ref is not None:
             self._values["ref"] = ref
         if repository is not None:
@@ -676,6 +939,17 @@ class CheckoutWith:
         result = self._values.get("lfs")
         return typing.cast(typing.Optional[builtins.bool], result)
 
+    @builtins.property
+    def path(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Relative path under $GITHUB_WORKSPACE to place the repository.
+
+        :default: - $GITHUB_WORKSPACE
+
+        :stability: experimental
+        '''
+        result = self._values.get("path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def ref(self) -> typing.Optional[builtins.str]:
         '''(experimental) Branch or tag name.
@@ -730,6 +1004,7 @@ class CheckoutWith:
     name_mapping={
         "fetch_depth": "fetchDepth",
         "lfs": "lfs",
+        "path": "path",
         "ref": "ref",
         "repository": "repository",
         "token": "token",
@@ -742,6 +1017,7 @@ class CheckoutWithPatchOptions(CheckoutWith):
         *,
         fetch_depth: typing.Optional[jsii.Number] = None,
         lfs: typing.Optional[builtins.bool] = None,
+        path: typing.Optional[builtins.str] = None,
         ref: typing.Optional[builtins.str] = None,
         repository: typing.Optional[builtins.str] = None,
         token: typing.Optional[builtins.str] = None,
@@ -751,6 +1027,7 @@ class CheckoutWithPatchOptions(CheckoutWith):
 
         :param fetch_depth: (experimental) Number of commits to fetch. 0 indicates all history for all branches and tags. Default: 1
         :param lfs: (experimental) Whether LFS is enabled for the GitHub repository. Default: false
+        :param path: (experimental) Relative path under $GITHUB_WORKSPACE to place the repository. Default: - $GITHUB_WORKSPACE
         :param ref: (experimental) Branch or tag name. Default: - the default branch is implicitly used
         :param repository: (experimental) The repository (owner/repo) to use. Default: - the default repository is implicitly used
         :param token: (experimental) A GitHub token to use when checking out the repository. If the intent is to push changes back to the branch, then you must use a PAT with ``repo`` (and possibly ``workflows``) permissions. Default: - the default GITHUB_TOKEN is implicitly used
@@ -762,6 +1039,7 @@ class CheckoutWithPatchOptions(CheckoutWith):
             type_hints = typing.get_type_hints(_typecheckingstub__c7405ea05e49b1f743e00dc103618fbd659c979bbec234492b8928ed6cf37e9b)
             check_type(argname="argument fetch_depth", value=fetch_depth, expected_type=type_hints["fetch_depth"])
             check_type(argname="argument lfs", value=lfs, expected_type=type_hints["lfs"])
+            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
             check_type(argname="argument ref", value=ref, expected_type=type_hints["ref"])
             check_type(argname="argument repository", value=repository, expected_type=type_hints["repository"])
             check_type(argname="argument token", value=token, expected_type=type_hints["token"])
@@ -771,6 +1049,8 @@ class CheckoutWithPatchOptions(CheckoutWith):
             self._values["fetch_depth"] = fetch_depth
         if lfs is not None:
             self._values["lfs"] = lfs
+        if path is not None:
+            self._values["path"] = path
         if ref is not None:
             self._values["ref"] = ref
         if repository is not None:
@@ -804,6 +1084,17 @@ class CheckoutWithPatchOptions(CheckoutWith):
         result = self._values.get("lfs")
         return typing.cast(typing.Optional[builtins.bool], result)
 
+    @builtins.property
+    def path(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Relative path under $GITHUB_WORKSPACE to place the repository.
+
+        :default: - $GITHUB_WORKSPACE
+
+        :stability: experimental
+        '''
+        result = self._values.get("path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def ref(self) -> typing.Optional[builtins.str]:
         '''(experimental) Branch or tag name.
@@ -863,6 +1154,73 @@ class CheckoutWithPatchOptions(CheckoutWith):
         )
 
 
+@jsii.data_type(
+    jsii_type="projen.github.ConcurrencyOptions",
+    jsii_struct_bases=[],
+    name_mapping={"cancel_in_progress": "cancelInProgress", "group": "group"},
+)
+class ConcurrencyOptions:
+    def __init__(
+        self,
+        *,
+        cancel_in_progress: typing.Optional[builtins.bool] = None,
+        group: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''(experimental) Options for ``concurrency``.
+
+        :param cancel_in_progress: (experimental) When a workflow is triggered while another one (in the same group) is running, should GitHub cancel the running workflow? Default: false
+        :param group: (experimental) Concurrency group controls which workflow runs will share the same concurrency limit. For example, if you specify ``${{ github.workflow }}-${{ github.ref }}``, workflow runs triggered on the same branch cannot run concurrenty, but workflows runs triggered on different branches can. Default: - ${{ github.workflow }}
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c4114f6f3330f94beb00dba1183281a663b31179a714c1f1412277b784153015)
+            check_type(argname="argument cancel_in_progress", value=cancel_in_progress, expected_type=type_hints["cancel_in_progress"])
+            check_type(argname="argument group", value=group, expected_type=type_hints["group"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if cancel_in_progress is not None:
+            self._values["cancel_in_progress"] = cancel_in_progress
+        if group is not None:
+            self._values["group"] = group
+
+    @builtins.property
+    def cancel_in_progress(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) When a workflow is triggered while another one (in the same group) is running, should GitHub cancel the running workflow?
+
+        :default: false
+
+        :stability: experimental
+        '''
+        result = self._values.get("cancel_in_progress")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def group(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Concurrency group controls which workflow runs will share the same concurrency limit.
+
+        For example, if you specify ``${{ github.workflow }}-${{ github.ref }}``, workflow runs triggered
+        on the same branch cannot run concurrenty, but workflows runs triggered on different branches can.
+
+        :default: - ${{ github.workflow }}
+
+        :see: https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/using-concurrency#example-concurrency-groups
+        :stability: experimental
+        '''
+        result = self._values.get("group")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "ConcurrencyOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="projen.github.ContributorStatementOptions",
     jsii_struct_bases=[],
@@ -969,7 +1327,7 @@ class CreatePullRequestOptions:
         :param base_branch: (experimental) Sets the pull request base branch. Default: - The branch checked out in the workflow.
         :param branch_name: (experimental) The pull request branch name. Default: ``github-actions/${options.workflowName}``
         :param credentials: (experimental) The job credentials used to create the pull request. Provided credentials must have permissions to create a pull request on the repository.
-        :param git_identity: (experimental) The git identity used to create the commit. Default: - the default github-actions user
+        :param git_identity: (experimental) The git identity used to create the commit. Default: - default GitHub Actions user
         :param labels: (experimental) Labels to apply on the PR. Default: - no labels.
         :param signoff: (experimental) Add Signed-off-by line by the committer at the end of the commit log message. Default: true
         :param step_id: (experimental) The step ID which produces the output which indicates if a patch was created. Default: "create_pr"
@@ -1099,7 +1457,7 @@ class CreatePullRequestOptions:
     def git_identity(self) -> typing.Optional["GitIdentity"]:
         '''(experimental) The git identity used to create the commit.
 
-        :default: - the default github-actions user
+        :default: - default GitHub Actions user
 
         :stability: experimental
         '''
@@ -1190,6 +1548,7 @@ class Dependabot(
         registries: typing.Optional[typing.Mapping[builtins.str, typing.Union["DependabotRegistry", typing.Dict[builtins.str, typing.Any]]]] = None,
         reviewers: typing.Optional[typing.Sequence[builtins.str]] = None,
         schedule_interval: typing.Optional["DependabotScheduleInterval"] = None,
+        target_branch: typing.Optional[builtins.str] = None,
         versioning_strategy: typing.Optional["VersioningStrategy"] = None,
     ) -> None:
         '''
@@ -1204,6 +1563,7 @@ class Dependabot(
         :param registries: (experimental) Map of package registries to use. Default: - use public registries
         :param reviewers: (experimental) Specify individual reviewers or teams of reviewers for all pull requests raised for a package manager. Default: []
         :param schedule_interval: (experimental) How often to check for new versions and raise pull requests. Default: ScheduleInterval.DAILY
+        :param target_branch: (experimental) https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#target-branch You can configure the target branch for raising pull requests for version updates against.
         :param versioning_strategy: (experimental) The strategy to use when edits manifest and lock files. Default: VersioningStrategy.LOCKFILE_ONLY The default is to only update the lock file because package.json is controlled by projen and any outside updates will fail the build.
 
         :stability: experimental
@@ -1222,6 +1582,7 @@ class Dependabot(
             registries=registries,
             reviewers=reviewers,
             schedule_interval=schedule_interval,
+            target_branch=target_branch,
             versioning_strategy=versioning_strategy,
         )
 
@@ -1329,31 +1690,53 @@ class DependabotAllow:
 @jsii.data_type(
     jsii_type="projen.github.DependabotGroup",
     jsii_struct_bases=[],
-    name_mapping={"patterns": "patterns", "exclude_patterns": "excludePatterns"},
+    name_mapping={
+        "patterns": "patterns",
+        "applies_to": "appliesTo",
+        "dependency_type": "dependencyType",
+        "exclude_patterns": "excludePatterns",
+        "update_types": "updateTypes",
+    },
 )
 class DependabotGroup:
     def __init__(
         self,
         *,
         patterns: typing.Sequence[builtins.str],
+        applies_to: typing.Optional["DependabotGroupAppliesTo"] = None,
+        dependency_type: typing.Optional["DependabotGroupDependencyType"] = None,
         exclude_patterns: typing.Optional[typing.Sequence[builtins.str]] = None,
+        update_types: typing.Optional[typing.Sequence["DependabotGroupUpdateType"]] = None,
     ) -> None:
         '''(experimental) Defines a single group for dependency updates.
 
         :param patterns: (experimental) Define a list of strings (with or without wildcards) that will match package names to form this dependency group.
+        :param applies_to: (experimental) Specify which type of update the group applies to. Default: - version updates
+        :param dependency_type: (experimental) Limit the group to a type of dependency. Default: - all types of dependencies
         :param exclude_patterns: (experimental) Optionally you can use this to exclude certain dependencies from the group.
+        :param update_types: (experimental) Limit the group to one or more semantic versioning levels. If specified, must contain at least one element and elements must be unique. Default: - all semantic versioning levels
 
+        :see: https://docs.github.com/en/code-security/dependabot/working-with-dependabot/dependabot-options-reference#groups--
         :stability: experimental
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__97650f1e1a170d34a5bd50211445090d04d890ec494749c1eb3f5a1fabbec7d4)
             check_type(argname="argument patterns", value=patterns, expected_type=type_hints["patterns"])
+            check_type(argname="argument applies_to", value=applies_to, expected_type=type_hints["applies_to"])
+            check_type(argname="argument dependency_type", value=dependency_type, expected_type=type_hints["dependency_type"])
             check_type(argname="argument exclude_patterns", value=exclude_patterns, expected_type=type_hints["exclude_patterns"])
+            check_type(argname="argument update_types", value=update_types, expected_type=type_hints["update_types"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "patterns": patterns,
         }
+        if applies_to is not None:
+            self._values["applies_to"] = applies_to
+        if dependency_type is not None:
+            self._values["dependency_type"] = dependency_type
         if exclude_patterns is not None:
             self._values["exclude_patterns"] = exclude_patterns
+        if update_types is not None:
+            self._values["update_types"] = update_types
 
     @builtins.property
     def patterns(self) -> typing.List[builtins.str]:
@@ -1365,6 +1748,29 @@ class DependabotGroup:
         assert result is not None, "Required property 'patterns' is missing"
         return typing.cast(typing.List[builtins.str], result)
 
+    @builtins.property
+    def applies_to(self) -> typing.Optional["DependabotGroupAppliesTo"]:
+        '''(experimental) Specify which type of update the group applies to.
+
+        :default: - version updates
+
+        :stability: experimental
+        '''
+        result = self._values.get("applies_to")
+        return typing.cast(typing.Optional["DependabotGroupAppliesTo"], result)
+
+    @builtins.property
+    def dependency_type(self) -> typing.Optional["DependabotGroupDependencyType"]:
+        '''(experimental) Limit the group to a type of dependency.
+
+        :default: - all types of dependencies
+
+        :see: https://docs.github.com/en/code-security/dependabot/working-with-dependabot/dependabot-options-reference#dependency-type-groups
+        :stability: experimental
+        '''
+        result = self._values.get("dependency_type")
+        return typing.cast(typing.Optional["DependabotGroupDependencyType"], result)
+
     @builtins.property
     def exclude_patterns(self) -> typing.Optional[typing.List[builtins.str]]:
         '''(experimental) Optionally you can use this to exclude certain dependencies from the group.
@@ -1374,6 +1780,20 @@ class DependabotGroup:
         result = self._values.get("exclude_patterns")
         return typing.cast(typing.Optional[typing.List[builtins.str]], result)
 
+    @builtins.property
+    def update_types(self) -> typing.Optional[typing.List["DependabotGroupUpdateType"]]:
+        '''(experimental) Limit the group to one or more semantic versioning levels.
+
+        If specified, must contain at least one element and elements must be unique.
+
+        :default: - all semantic versioning levels
+
+        :see: https://docs.github.com/en/code-security/dependabot/working-with-dependabot/dependabot-options-reference#update-types-groups
+        :stability: experimental
+        '''
+        result = self._values.get("update_types")
+        return typing.cast(typing.Optional[typing.List["DependabotGroupUpdateType"]], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -1386,26 +1806,88 @@ class DependabotGroup:
         )
 
 
-@jsii.data_type(
-    jsii_type="projen.github.DependabotIgnore",
-    jsii_struct_bases=[],
-    name_mapping={"dependency_name": "dependencyName", "versions": "versions"},
-)
-class DependabotIgnore:
-    def __init__(
-        self,
-        *,
-        dependency_name: builtins.str,
-        versions: typing.Optional[typing.Sequence[builtins.str]] = None,
-    ) -> None:
-        '''(experimental) You can use the ``ignore`` option to customize which dependencies are updated.
+@jsii.enum(jsii_type="projen.github.DependabotGroupAppliesTo")
+class DependabotGroupAppliesTo(enum.Enum):
+    '''(experimental) The type of update a group applies to.
 
-        The ignore option supports the following options.
+    :stability: experimental
+    '''
 
-        :param dependency_name: (experimental) Use to ignore updates for dependencies with matching names, optionally using ``*`` to match zero or more characters. For Java dependencies, the format of the dependency-name attribute is: ``groupId:artifactId``, for example: ``org.kohsuke:github-api``.
-        :param versions: (experimental) Use to ignore specific versions or ranges of versions. If you want to define a range, use the standard pattern for the package manager (for example: ``^1.0.0`` for npm, or ``~> 2.0`` for Bundler).
+    VERSION_UPDATES = "VERSION_UPDATES"
+    '''(experimental) Apply only to version updates.
 
-        :stability: experimental
+    :stability: experimental
+    '''
+    SECURITY_UPDATES = "SECURITY_UPDATES"
+    '''(experimental) Apply only to security updates.
+
+    :stability: experimental
+    '''
+
+
+@jsii.enum(jsii_type="projen.github.DependabotGroupDependencyType")
+class DependabotGroupDependencyType(enum.Enum):
+    '''(experimental) The type of dependency a group may be limited to.
+
+    :stability: experimental
+    '''
+
+    DEVELOPMENT = "DEVELOPMENT"
+    '''(experimental) Include only dependencies in the "Development dependency group".
+
+    :stability: experimental
+    '''
+    PRODUCTION = "PRODUCTION"
+    '''(experimental) Include only dependencies in the "Production dependency group".
+
+    :stability: experimental
+    '''
+
+
+@jsii.enum(jsii_type="projen.github.DependabotGroupUpdateType")
+class DependabotGroupUpdateType(enum.Enum):
+    '''(experimental) The semantic versioning levels a group may be limited to.
+
+    :stability: experimental
+    '''
+
+    MAJOR = "MAJOR"
+    '''(experimental) Include major releases.
+
+    :stability: experimental
+    '''
+    MINOR = "MINOR"
+    '''(experimental) Include minor releases.
+
+    :stability: experimental
+    '''
+    PATCH = "PATCH"
+    '''(experimental) Include patch releases.
+
+    :stability: experimental
+    '''
+
+
+@jsii.data_type(
+    jsii_type="projen.github.DependabotIgnore",
+    jsii_struct_bases=[],
+    name_mapping={"dependency_name": "dependencyName", "versions": "versions"},
+)
+class DependabotIgnore:
+    def __init__(
+        self,
+        *,
+        dependency_name: builtins.str,
+        versions: typing.Optional[typing.Sequence[builtins.str]] = None,
+    ) -> None:
+        '''(experimental) You can use the ``ignore`` option to customize which dependencies are updated.
+
+        The ignore option supports the following options.
+
+        :param dependency_name: (experimental) Use to ignore updates for dependencies with matching names, optionally using ``*`` to match zero or more characters. For Java dependencies, the format of the dependency-name attribute is: ``groupId:artifactId``, for example: ``org.kohsuke:github-api``.
+        :param versions: (experimental) Use to ignore specific versions or ranges of versions. If you want to define a range, use the standard pattern for the package manager (for example: ``^1.0.0`` for npm, or ``~> 2.0`` for Bundler).
+
+        :stability: experimental
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__e56f402ddf44883464ec12efeaccc97a7e042d533028c01db1fcda57dd3859c8)
@@ -1469,6 +1951,7 @@ class DependabotIgnore:
         "registries": "registries",
         "reviewers": "reviewers",
         "schedule_interval": "scheduleInterval",
+        "target_branch": "targetBranch",
         "versioning_strategy": "versioningStrategy",
     },
 )
@@ -1486,6 +1969,7 @@ class DependabotOptions:
         registries: typing.Optional[typing.Mapping[builtins.str, typing.Union["DependabotRegistry", typing.Dict[builtins.str, typing.Any]]]] = None,
         reviewers: typing.Optional[typing.Sequence[builtins.str]] = None,
         schedule_interval: typing.Optional["DependabotScheduleInterval"] = None,
+        target_branch: typing.Optional[builtins.str] = None,
         versioning_strategy: typing.Optional["VersioningStrategy"] = None,
     ) -> None:
         '''
@@ -1499,6 +1983,7 @@ class DependabotOptions:
         :param registries: (experimental) Map of package registries to use. Default: - use public registries
         :param reviewers: (experimental) Specify individual reviewers or teams of reviewers for all pull requests raised for a package manager. Default: []
         :param schedule_interval: (experimental) How often to check for new versions and raise pull requests. Default: ScheduleInterval.DAILY
+        :param target_branch: (experimental) https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#target-branch You can configure the target branch for raising pull requests for version updates against.
         :param versioning_strategy: (experimental) The strategy to use when edits manifest and lock files. Default: VersioningStrategy.LOCKFILE_ONLY The default is to only update the lock file because package.json is controlled by projen and any outside updates will fail the build.
 
         :stability: experimental
@@ -1515,6 +2000,7 @@ class DependabotOptions:
             check_type(argname="argument registries", value=registries, expected_type=type_hints["registries"])
             check_type(argname="argument reviewers", value=reviewers, expected_type=type_hints["reviewers"])
             check_type(argname="argument schedule_interval", value=schedule_interval, expected_type=type_hints["schedule_interval"])
+            check_type(argname="argument target_branch", value=target_branch, expected_type=type_hints["target_branch"])
             check_type(argname="argument versioning_strategy", value=versioning_strategy, expected_type=type_hints["versioning_strategy"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
         if allow is not None:
@@ -1537,6 +2023,8 @@ class DependabotOptions:
             self._values["reviewers"] = reviewers
         if schedule_interval is not None:
             self._values["schedule_interval"] = schedule_interval
+        if target_branch is not None:
+            self._values["target_branch"] = target_branch
         if versioning_strategy is not None:
             self._values["versioning_strategy"] = versioning_strategy
 
@@ -1665,6 +2153,15 @@ class DependabotOptions:
         result = self._values.get("schedule_interval")
         return typing.cast(typing.Optional["DependabotScheduleInterval"], result)
 
+    @builtins.property
+    def target_branch(self) -> typing.Optional[builtins.str]:
+        '''(experimental) https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#target-branch You can configure the target branch for raising pull requests for version updates against.
+
+        :stability: experimental
+        '''
+        result = self._values.get("target_branch")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def versioning_strategy(self) -> typing.Optional["VersioningStrategy"]:
         '''(experimental) The strategy to use when edits manifest and lock files.
@@ -1961,147 +2458,497 @@ class DependabotScheduleInterval(enum.Enum):
     '''
 
 
-class GitHub(
-    _Component_2b0ad27f,
-    metaclass=jsii.JSIIMeta,
-    jsii_type="projen.github.GitHub",
-):
-    '''
-    :stability: experimental
-    '''
-
+@jsii.data_type(
+    jsii_type="projen.github.DownloadArtifactOptions",
+    jsii_struct_bases=[_JobStepConfiguration_9caff420],
+    name_mapping={
+        "env": "env",
+        "id": "id",
+        "if_": "if",
+        "name": "name",
+        "shell": "shell",
+        "working_directory": "workingDirectory",
+        "continue_on_error": "continueOnError",
+        "timeout_minutes": "timeoutMinutes",
+        "with_": "with",
+    },
+)
+class DownloadArtifactOptions(_JobStepConfiguration_9caff420):
     def __init__(
         self,
-        project: _Project_57d89203,
         *,
-        download_lfs: typing.Optional[builtins.bool] = None,
-        mergify: typing.Optional[builtins.bool] = None,
-        mergify_options: typing.Optional[typing.Union["MergifyOptions", typing.Dict[builtins.str, typing.Any]]] = None,
-        projen_credentials: typing.Optional["GithubCredentials"] = None,
-        projen_token_secret: typing.Optional[builtins.str] = None,
-        pull_request_lint: typing.Optional[builtins.bool] = None,
-        pull_request_lint_options: typing.Optional[typing.Union["PullRequestLintOptions", typing.Dict[builtins.str, typing.Any]]] = None,
-        workflows: typing.Optional[builtins.bool] = None,
+        env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        id: typing.Optional[builtins.str] = None,
+        if_: typing.Optional[builtins.str] = None,
+        name: typing.Optional[builtins.str] = None,
+        shell: typing.Optional[builtins.str] = None,
+        working_directory: typing.Optional[builtins.str] = None,
+        continue_on_error: typing.Optional[builtins.bool] = None,
+        timeout_minutes: typing.Optional[jsii.Number] = None,
+        with_: typing.Union["DownloadArtifactWith", typing.Dict[builtins.str, typing.Any]],
     ) -> None:
         '''
-        :param project: -
-        :param download_lfs: (experimental) Download files in LFS in workflows. Default: true if the associated project has ``lfsPatterns``, ``false`` otherwise
-        :param mergify: (experimental) Whether mergify should be enabled on this repository or not. Default: true
-        :param mergify_options: (experimental) Options for Mergify. Default: - default options
-        :param projen_credentials: (experimental) Choose a method of providing GitHub API access for projen workflows. Default: - use a personal access token named PROJEN_GITHUB_TOKEN
-        :param projen_token_secret: (deprecated) The name of a secret which includes a GitHub Personal Access Token to be used by projen workflows. This token needs to have the ``repo``, ``workflows`` and ``packages`` scope. Default: "PROJEN_GITHUB_TOKEN"
-        :param pull_request_lint: (experimental) Add a workflow that performs basic checks for pull requests, like validating that PRs follow Conventional Commits. Default: true
-        :param pull_request_lint_options: (experimental) Options for configuring a pull request linter. Default: - see defaults in ``PullRequestLintOptions``
-        :param workflows: (experimental) Enables GitHub workflows. If this is set to ``false``, workflows will not be created. Default: true
+        :param env: (experimental) Sets environment variables for steps to use in the runner environment. You can also set environment variables for the entire workflow or a job.
+        :param id: (experimental) A unique identifier for the step. You can use the id to reference the step in contexts.
+        :param if_: (experimental) You can use the if conditional to prevent a job from running unless a condition is met. You can use any supported context and expression to create a conditional.
+        :param name: (experimental) A name for your step to display on GitHub.
+        :param shell: (experimental) Overrides the default shell settings in the runner's operating system and the job's default. Refer to GitHub documentation for allowed values.
+        :param working_directory: (experimental) Specifies a working directory for a step. Overrides a job's working directory.
+        :param continue_on_error: (experimental) Prevents a job from failing when a step fails. Set to true to allow a job to pass when this step fails.
+        :param timeout_minutes: (experimental) The maximum number of minutes to run the step before killing the process.
+        :param with_: (experimental) Options for ``download-artifact``.
 
         :stability: experimental
         '''
+        if isinstance(with_, dict):
+            with_ = DownloadArtifactWith(**with_)
         if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__65db11e8703472c7fa4e013294c649e43b7f8634b29ca11be71b46d8c549c4d1)
-            check_type(argname="argument project", value=project, expected_type=type_hints["project"])
-        options = GitHubOptions(
-            download_lfs=download_lfs,
-            mergify=mergify,
-            mergify_options=mergify_options,
-            projen_credentials=projen_credentials,
-            projen_token_secret=projen_token_secret,
-            pull_request_lint=pull_request_lint,
-            pull_request_lint_options=pull_request_lint_options,
-            workflows=workflows,
-        )
-
-        jsii.create(self.__class__, self, [project, options])
+            type_hints = typing.get_type_hints(_typecheckingstub__c7f153d5c1001fcb119385a05448ea85e212f46cc420d578734261b8353a641b)
+            check_type(argname="argument env", value=env, expected_type=type_hints["env"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+            check_type(argname="argument if_", value=if_, expected_type=type_hints["if_"])
+            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument shell", value=shell, expected_type=type_hints["shell"])
+            check_type(argname="argument working_directory", value=working_directory, expected_type=type_hints["working_directory"])
+            check_type(argname="argument continue_on_error", value=continue_on_error, expected_type=type_hints["continue_on_error"])
+            check_type(argname="argument timeout_minutes", value=timeout_minutes, expected_type=type_hints["timeout_minutes"])
+            check_type(argname="argument with_", value=with_, expected_type=type_hints["with_"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "with_": with_,
+        }
+        if env is not None:
+            self._values["env"] = env
+        if id is not None:
+            self._values["id"] = id
+        if if_ is not None:
+            self._values["if_"] = if_
+        if name is not None:
+            self._values["name"] = name
+        if shell is not None:
+            self._values["shell"] = shell
+        if working_directory is not None:
+            self._values["working_directory"] = working_directory
+        if continue_on_error is not None:
+            self._values["continue_on_error"] = continue_on_error
+        if timeout_minutes is not None:
+            self._values["timeout_minutes"] = timeout_minutes
 
-    @jsii.member(jsii_name="of")
-    @builtins.classmethod
-    def of(cls, project: _Project_57d89203) -> typing.Optional["GitHub"]:
-        '''(experimental) Returns the ``GitHub`` component of a project or ``undefined`` if the project does not have a GitHub component.
+    @builtins.property
+    def env(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
+        '''(experimental) Sets environment variables for steps to use in the runner environment.
 
-        :param project: -
+        You can also set environment variables for the entire workflow or a job.
 
         :stability: experimental
         '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__f1f9f6e10bd4208bf86fd269c2d9b1be37bfe497219300efebf37a151efc972e)
-            check_type(argname="argument project", value=project, expected_type=type_hints["project"])
-        return typing.cast(typing.Optional["GitHub"], jsii.sinvoke(cls, "of", [project]))
+        result = self._values.get("env")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
 
-    @jsii.member(jsii_name="addDependabot")
-    def add_dependabot(
-        self,
-        *,
-        allow: typing.Optional[typing.Sequence[typing.Union[DependabotAllow, typing.Dict[builtins.str, typing.Any]]]] = None,
-        assignees: typing.Optional[typing.Sequence[builtins.str]] = None,
-        groups: typing.Optional[typing.Mapping[builtins.str, typing.Union[DependabotGroup, typing.Dict[builtins.str, typing.Any]]]] = None,
-        ignore: typing.Optional[typing.Sequence[typing.Union[DependabotIgnore, typing.Dict[builtins.str, typing.Any]]]] = None,
-        ignore_projen: typing.Optional[builtins.bool] = None,
-        labels: typing.Optional[typing.Sequence[builtins.str]] = None,
-        open_pull_requests_limit: typing.Optional[jsii.Number] = None,
-        registries: typing.Optional[typing.Mapping[builtins.str, typing.Union[DependabotRegistry, typing.Dict[builtins.str, typing.Any]]]] = None,
-        reviewers: typing.Optional[typing.Sequence[builtins.str]] = None,
-        schedule_interval: typing.Optional[DependabotScheduleInterval] = None,
-        versioning_strategy: typing.Optional["VersioningStrategy"] = None,
-    ) -> Dependabot:
-        '''
-        :param allow: (experimental) https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#allow. Use the allow option to customize which dependencies are updated. This applies to both version and security updates. Default: []
-        :param assignees: (experimental) Specify individual assignees or teams of assignees for all pull requests raised for a package manager. Default: []
-        :param groups: (experimental) https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#groups. You can create groups to package dependency updates together into a single PR. Default: []
-        :param ignore: (experimental) You can use the ``ignore`` option to customize which dependencies are updated. The ignore option supports the following options. Default: []
-        :param ignore_projen: (experimental) Ignores updates to ``projen``. This is required since projen updates may cause changes in committed files and anti-tamper checks will fail. Projen upgrades are covered through the ``ProjenUpgrade`` class. Default: true
-        :param labels: (experimental) List of labels to apply to the created PR's.
-        :param open_pull_requests_limit: (experimental) Sets the maximum of pull requests Dependabot opens for version updates. Dependabot will not open any new requests until some of those open requests are merged or closed. Default: 5
-        :param registries: (experimental) Map of package registries to use. Default: - use public registries
-        :param reviewers: (experimental) Specify individual reviewers or teams of reviewers for all pull requests raised for a package manager. Default: []
-        :param schedule_interval: (experimental) How often to check for new versions and raise pull requests. Default: ScheduleInterval.DAILY
-        :param versioning_strategy: (experimental) The strategy to use when edits manifest and lock files. Default: VersioningStrategy.LOCKFILE_ONLY The default is to only update the lock file because package.json is controlled by projen and any outside updates will fail the build.
+    @builtins.property
+    def id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) A unique identifier for the step.
+
+        You can use the id to reference the
+        step in contexts.
 
         :stability: experimental
         '''
-        options = DependabotOptions(
-            allow=allow,
-            assignees=assignees,
-            groups=groups,
-            ignore=ignore,
-            ignore_projen=ignore_projen,
-            labels=labels,
-            open_pull_requests_limit=open_pull_requests_limit,
-            registries=registries,
-            reviewers=reviewers,
-            schedule_interval=schedule_interval,
-            versioning_strategy=versioning_strategy,
-        )
+        result = self._values.get("id")
+        return typing.cast(typing.Optional[builtins.str], result)
 
-        return typing.cast(Dependabot, jsii.invoke(self, "addDependabot", [options]))
+    @builtins.property
+    def if_(self) -> typing.Optional[builtins.str]:
+        '''(experimental) You can use the if conditional to prevent a job from running unless a condition is met.
 
-    @jsii.member(jsii_name="addPullRequestTemplate")
-    def add_pull_request_template(
-        self,
-        *content: builtins.str,
-    ) -> "PullRequestTemplate":
-        '''
-        :param content: -
+        You can use any supported context and expression to
+        create a conditional.
 
         :stability: experimental
         '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__4837ecd412981af090d26642873c81c7ca7b69a5c2079c390fb0d3d7168522ff)
-            check_type(argname="argument content", value=content, expected_type=typing.Tuple[type_hints["content"], ...]) # pyright: ignore [reportGeneralTypeIssues]
-        return typing.cast("PullRequestTemplate", jsii.invoke(self, "addPullRequestTemplate", [*content]))
+        result = self._values.get("if_")
+        return typing.cast(typing.Optional[builtins.str], result)
 
-    @jsii.member(jsii_name="addWorkflow")
-    def add_workflow(self, name: builtins.str) -> "GithubWorkflow":
-        '''(experimental) Adds a workflow to the project.
+    @builtins.property
+    def name(self) -> typing.Optional[builtins.str]:
+        '''(experimental) A name for your step to display on GitHub.
 
-        :param name: Name of the workflow.
+        :stability: experimental
+        '''
+        result = self._values.get("name")
+        return typing.cast(typing.Optional[builtins.str], result)
 
-        :return: a GithubWorkflow instance
+    @builtins.property
+    def shell(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Overrides the default shell settings in the runner's operating system and the job's default.
 
+        Refer to GitHub documentation for allowed values.
+
+        :see: https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsshell
         :stability: experimental
         '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__79e4dc466f25fa1bf920982b1e4d0a98ce7f5ac928835c4607e7f8879a2e1d06)
-            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
-        return typing.cast("GithubWorkflow", jsii.invoke(self, "addWorkflow", [name]))
+        result = self._values.get("shell")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def working_directory(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Specifies a working directory for a step.
+
+        Overrides a job's working directory.
+
+        :stability: experimental
+        '''
+        result = self._values.get("working_directory")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def continue_on_error(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Prevents a job from failing when a step fails.
+
+        Set to true to allow a job
+        to pass when this step fails.
+
+        :stability: experimental
+        '''
+        result = self._values.get("continue_on_error")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def timeout_minutes(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) The maximum number of minutes to run the step before killing the process.
+
+        :stability: experimental
+        '''
+        result = self._values.get("timeout_minutes")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def with_(self) -> "DownloadArtifactWith":
+        '''(experimental) Options for ``download-artifact``.
+
+        :stability: experimental
+        '''
+        result = self._values.get("with_")
+        assert result is not None, "Required property 'with_' is missing"
+        return typing.cast("DownloadArtifactWith", result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "DownloadArtifactOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="projen.github.DownloadArtifactWith",
+    jsii_struct_bases=[],
+    name_mapping={
+        "merge_multiple": "mergeMultiple",
+        "name": "name",
+        "path": "path",
+        "pattern": "pattern",
+        "repository": "repository",
+        "run_id": "runId",
+        "token": "token",
+    },
+)
+class DownloadArtifactWith:
+    def __init__(
+        self,
+        *,
+        merge_multiple: typing.Optional[builtins.bool] = None,
+        name: typing.Optional[builtins.str] = None,
+        path: typing.Optional[builtins.str] = None,
+        pattern: typing.Optional[builtins.str] = None,
+        repository: typing.Optional[builtins.str] = None,
+        run_id: typing.Optional[builtins.str] = None,
+        token: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''
+        :param merge_multiple: (experimental) When multiple artifacts are matched, this changes the behavior of the destination directories If true, the downloaded artifacts will be in the same directory specified by path If false, the downloaded artifacts will be extracted into individual named directories within the specified path. Default: false
+        :param name: (experimental) Name of the artifact to download. Default: - If unspecified, all artifacts for the run are downloaded
+        :param path: (experimental) A file, directory or wildcard pattern that describes what to download. Supports basic tilde expansion. Default: - $GITHUB_WORKSPACE
+        :param pattern: (experimental) A glob pattern to the artifacts that should be downloaded This is ignored if name is specified.
+        :param repository: (experimental) The repository owner and the repository name joined together by "/" If github-token is specified, this is the repository that artifacts will be downloaded from. Default: - ${{ github.repository }}
+        :param run_id: (experimental) The id of the workflow run where the desired download artifact was uploaded from If github-token is specified, this is the run that artifacts will be downloaded from. Default: - ${{ github.run_id }}
+        :param token: (experimental) The GitHub token used to authenticate with the GitHub API to download artifacts from a different repository or from a different workflow run. Default: - If unspecified, the action will download artifacts from the current repo and the current workflow run
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__3e5008f68a85d8490ecf62a54f413b82cc795d9a14d3bc8eabcc2720f31de50c)
+            check_type(argname="argument merge_multiple", value=merge_multiple, expected_type=type_hints["merge_multiple"])
+            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
+            check_type(argname="argument pattern", value=pattern, expected_type=type_hints["pattern"])
+            check_type(argname="argument repository", value=repository, expected_type=type_hints["repository"])
+            check_type(argname="argument run_id", value=run_id, expected_type=type_hints["run_id"])
+            check_type(argname="argument token", value=token, expected_type=type_hints["token"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if merge_multiple is not None:
+            self._values["merge_multiple"] = merge_multiple
+        if name is not None:
+            self._values["name"] = name
+        if path is not None:
+            self._values["path"] = path
+        if pattern is not None:
+            self._values["pattern"] = pattern
+        if repository is not None:
+            self._values["repository"] = repository
+        if run_id is not None:
+            self._values["run_id"] = run_id
+        if token is not None:
+            self._values["token"] = token
+
+    @builtins.property
+    def merge_multiple(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) When multiple artifacts are matched, this changes the behavior of the destination directories If true, the downloaded artifacts will be in the same directory specified by path If false, the downloaded artifacts will be extracted into individual named directories within the specified path.
+
+        :default: false
+
+        :stability: experimental
+        '''
+        result = self._values.get("merge_multiple")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def name(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Name of the artifact to download.
+
+        :default: - If unspecified, all artifacts for the run are downloaded
+
+        :stability: experimental
+        '''
+        result = self._values.get("name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def path(self) -> typing.Optional[builtins.str]:
+        '''(experimental) A file, directory or wildcard pattern that describes what to download.
+
+        Supports basic tilde expansion.
+
+        :default: - $GITHUB_WORKSPACE
+
+        :stability: experimental
+        '''
+        result = self._values.get("path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def pattern(self) -> typing.Optional[builtins.str]:
+        '''(experimental) A glob pattern to the artifacts that should be downloaded This is ignored if name is specified.
+
+        :stability: experimental
+        '''
+        result = self._values.get("pattern")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def repository(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The repository owner and the repository name joined together by "/" If github-token is specified, this is the repository that artifacts will be downloaded from.
+
+        :default: - ${{ github.repository }}
+
+        :stability: experimental
+        '''
+        result = self._values.get("repository")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def run_id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The id of the workflow run where the desired download artifact was uploaded from If github-token is specified, this is the run that artifacts will be downloaded from.
+
+        :default: - ${{ github.run_id }}
+
+        :stability: experimental
+        '''
+        result = self._values.get("run_id")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def token(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The GitHub token used to authenticate with the GitHub API to download artifacts from a different repository or from a different workflow run.
+
+        :default: - If unspecified, the action will download artifacts from the current repo and the current workflow run
+
+        :stability: experimental
+        '''
+        result = self._values.get("token")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "DownloadArtifactWith(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+class GitHub(
+    _Component_2b0ad27f,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="projen.github.GitHub",
+):
+    '''
+    :stability: experimental
+    '''
+
+    def __init__(
+        self,
+        project: _Project_57d89203,
+        *,
+        download_lfs: typing.Optional[builtins.bool] = None,
+        merge_queue: typing.Optional[builtins.bool] = None,
+        merge_queue_options: typing.Optional[typing.Union["MergeQueueOptions", typing.Dict[builtins.str, typing.Any]]] = None,
+        mergify: typing.Optional[builtins.bool] = None,
+        mergify_options: typing.Optional[typing.Union["MergifyOptions", typing.Dict[builtins.str, typing.Any]]] = None,
+        projen_credentials: typing.Optional["GithubCredentials"] = None,
+        projen_token_secret: typing.Optional[builtins.str] = None,
+        pull_request_backport: typing.Optional[builtins.bool] = None,
+        pull_request_backport_options: typing.Optional[typing.Union["PullRequestBackportOptions", typing.Dict[builtins.str, typing.Any]]] = None,
+        pull_request_lint: typing.Optional[builtins.bool] = None,
+        pull_request_lint_options: typing.Optional[typing.Union["PullRequestLintOptions", typing.Dict[builtins.str, typing.Any]]] = None,
+        workflows: typing.Optional[builtins.bool] = None,
+    ) -> None:
+        '''
+        :param project: -
+        :param download_lfs: (experimental) Download files in LFS in workflows. Default: true if the associated project has ``lfsPatterns``, ``false`` otherwise
+        :param merge_queue: (experimental) Whether a merge queue should be used on this repository to merge pull requests. Requires additional configuration of the repositories branch protection rules. Default: false
+        :param merge_queue_options: (experimental) Options for MergeQueue. Default: - default options
+        :param mergify: (experimental) Whether mergify should be enabled on this repository or not. Default: true
+        :param mergify_options: (experimental) Options for Mergify. Default: - default options
+        :param projen_credentials: (experimental) Choose a method of providing GitHub API access for projen workflows. Default: - use a personal access token named PROJEN_GITHUB_TOKEN
+        :param projen_token_secret: (deprecated) The name of a secret which includes a GitHub Personal Access Token to be used by projen workflows. This token needs to have the ``repo``, ``workflows`` and ``packages`` scope. Default: "PROJEN_GITHUB_TOKEN"
+        :param pull_request_backport: (experimental) Add a workflow that allows backport of PRs to other branches using labels. When opening a new PR add a backport label to it, and the PR will be backported to the target branches once the PR is merged. Should not be used together with mergify. Default: false
+        :param pull_request_backport_options: (experimental) Options for configuring pull request backport. Default: - see defaults in ``PullRequestBackportOptions``
+        :param pull_request_lint: (experimental) Add a workflow that performs basic checks for pull requests, like validating that PRs follow Conventional Commits. Default: true
+        :param pull_request_lint_options: (experimental) Options for configuring a pull request linter. Default: - see defaults in ``PullRequestLintOptions``
+        :param workflows: (experimental) Enables GitHub workflows. If this is set to ``false``, workflows will not be created. Default: true
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__65db11e8703472c7fa4e013294c649e43b7f8634b29ca11be71b46d8c549c4d1)
+            check_type(argname="argument project", value=project, expected_type=type_hints["project"])
+        options = GitHubOptions(
+            download_lfs=download_lfs,
+            merge_queue=merge_queue,
+            merge_queue_options=merge_queue_options,
+            mergify=mergify,
+            mergify_options=mergify_options,
+            projen_credentials=projen_credentials,
+            projen_token_secret=projen_token_secret,
+            pull_request_backport=pull_request_backport,
+            pull_request_backport_options=pull_request_backport_options,
+            pull_request_lint=pull_request_lint,
+            pull_request_lint_options=pull_request_lint_options,
+            workflows=workflows,
+        )
+
+        jsii.create(self.__class__, self, [project, options])
+
+    @jsii.member(jsii_name="of")
+    @builtins.classmethod
+    def of(cls, project: _Project_57d89203) -> typing.Optional["GitHub"]:
+        '''(experimental) Returns the ``GitHub`` component of a project or ``undefined`` if the project does not have a GitHub component.
+
+        :param project: -
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__f1f9f6e10bd4208bf86fd269c2d9b1be37bfe497219300efebf37a151efc972e)
+            check_type(argname="argument project", value=project, expected_type=type_hints["project"])
+        return typing.cast(typing.Optional["GitHub"], jsii.sinvoke(cls, "of", [project]))
+
+    @jsii.member(jsii_name="addDependabot")
+    def add_dependabot(
+        self,
+        *,
+        allow: typing.Optional[typing.Sequence[typing.Union[DependabotAllow, typing.Dict[builtins.str, typing.Any]]]] = None,
+        assignees: typing.Optional[typing.Sequence[builtins.str]] = None,
+        groups: typing.Optional[typing.Mapping[builtins.str, typing.Union[DependabotGroup, typing.Dict[builtins.str, typing.Any]]]] = None,
+        ignore: typing.Optional[typing.Sequence[typing.Union[DependabotIgnore, typing.Dict[builtins.str, typing.Any]]]] = None,
+        ignore_projen: typing.Optional[builtins.bool] = None,
+        labels: typing.Optional[typing.Sequence[builtins.str]] = None,
+        open_pull_requests_limit: typing.Optional[jsii.Number] = None,
+        registries: typing.Optional[typing.Mapping[builtins.str, typing.Union[DependabotRegistry, typing.Dict[builtins.str, typing.Any]]]] = None,
+        reviewers: typing.Optional[typing.Sequence[builtins.str]] = None,
+        schedule_interval: typing.Optional[DependabotScheduleInterval] = None,
+        target_branch: typing.Optional[builtins.str] = None,
+        versioning_strategy: typing.Optional["VersioningStrategy"] = None,
+    ) -> Dependabot:
+        '''
+        :param allow: (experimental) https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#allow. Use the allow option to customize which dependencies are updated. This applies to both version and security updates. Default: []
+        :param assignees: (experimental) Specify individual assignees or teams of assignees for all pull requests raised for a package manager. Default: []
+        :param groups: (experimental) https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#groups. You can create groups to package dependency updates together into a single PR. Default: []
+        :param ignore: (experimental) You can use the ``ignore`` option to customize which dependencies are updated. The ignore option supports the following options. Default: []
+        :param ignore_projen: (experimental) Ignores updates to ``projen``. This is required since projen updates may cause changes in committed files and anti-tamper checks will fail. Projen upgrades are covered through the ``ProjenUpgrade`` class. Default: true
+        :param labels: (experimental) List of labels to apply to the created PR's.
+        :param open_pull_requests_limit: (experimental) Sets the maximum of pull requests Dependabot opens for version updates. Dependabot will not open any new requests until some of those open requests are merged or closed. Default: 5
+        :param registries: (experimental) Map of package registries to use. Default: - use public registries
+        :param reviewers: (experimental) Specify individual reviewers or teams of reviewers for all pull requests raised for a package manager. Default: []
+        :param schedule_interval: (experimental) How often to check for new versions and raise pull requests. Default: ScheduleInterval.DAILY
+        :param target_branch: (experimental) https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#target-branch You can configure the target branch for raising pull requests for version updates against.
+        :param versioning_strategy: (experimental) The strategy to use when edits manifest and lock files. Default: VersioningStrategy.LOCKFILE_ONLY The default is to only update the lock file because package.json is controlled by projen and any outside updates will fail the build.
+
+        :stability: experimental
+        '''
+        options = DependabotOptions(
+            allow=allow,
+            assignees=assignees,
+            groups=groups,
+            ignore=ignore,
+            ignore_projen=ignore_projen,
+            labels=labels,
+            open_pull_requests_limit=open_pull_requests_limit,
+            registries=registries,
+            reviewers=reviewers,
+            schedule_interval=schedule_interval,
+            target_branch=target_branch,
+            versioning_strategy=versioning_strategy,
+        )
+
+        return typing.cast(Dependabot, jsii.invoke(self, "addDependabot", [options]))
+
+    @jsii.member(jsii_name="addPullRequestTemplate")
+    def add_pull_request_template(
+        self,
+        *content: builtins.str,
+    ) -> "PullRequestTemplate":
+        '''
+        :param content: -
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__4837ecd412981af090d26642873c81c7ca7b69a5c2079c390fb0d3d7168522ff)
+            check_type(argname="argument content", value=content, expected_type=typing.Tuple[type_hints["content"], ...]) # pyright: ignore [reportGeneralTypeIssues]
+        return typing.cast("PullRequestTemplate", jsii.invoke(self, "addPullRequestTemplate", [*content]))
+
+    @jsii.member(jsii_name="addWorkflow")
+    def add_workflow(self, name: builtins.str) -> "GithubWorkflow":
+        '''(experimental) Adds a workflow to the project.
+
+        :param name: Name of the workflow.
+
+        :return: a GithubWorkflow instance
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__79e4dc466f25fa1bf920982b1e4d0a98ce7f5ac928835c4607e7f8879a2e1d06)
+            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+        return typing.cast("GithubWorkflow", jsii.invoke(self, "addWorkflow", [name]))
 
     @jsii.member(jsii_name="tryFindWorkflow")
     def try_find_workflow(
@@ -2124,7 +2971,8 @@ class GitHub(
     @builtins.property
     @jsii.member(jsii_name="actions")
     def actions(self) -> "GitHubActionsProvider":
-        '''
+        '''(experimental) The GitHub Actions provider used to manage the versions of actions used in steps.
+
         :stability: experimental
         '''
         return typing.cast("GitHubActionsProvider", jsii.get(self, "actions"))
@@ -2165,13 +3013,19 @@ class GitHub(
         '''
         return typing.cast(builtins.bool, jsii.get(self, "workflowsEnabled"))
 
+    @builtins.property
+    @jsii.member(jsii_name="mergeQueue")
+    def merge_queue(self) -> typing.Optional["MergeQueue"]:
+        '''(experimental) The ``MergeQueue`` component configured on this repository This is ``undefined`` if merge queues are not enabled for this repository.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional["MergeQueue"], jsii.get(self, "mergeQueue"))
+
     @builtins.property
     @jsii.member(jsii_name="mergify")
     def mergify(self) -> typing.Optional["Mergify"]:
-        '''(experimental) The ``Mergify`` configured on this repository.
-
-        This is ``undefined`` if Mergify
-        was not enabled when creating the repository.
+        '''(experimental) The ``Mergify`` component configured on this repository This is ``undefined`` if Mergify is not enabled for this repository.
 
         :stability: experimental
         '''
@@ -2226,8 +3080,8 @@ class GitHubActionsProvider(
             // Force any use of `actions/checkout` to use a pin a specific commit
             project.github.actions.set("actions/checkout", "actions/checkout@aaaaaa");
             
-            // But pin usage of `v3` to a different commit
-            project.github.actions.set("actions/checkout@v3", "actions/checkout@ffffff");
+            // But pin usage of `v4` to a different commit
+            project.github.actions.set("actions/checkout@v4", "actions/checkout@ffffff");
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__20166ac47381861e1a45b550a5e9646380c52a927fca9ebf00ec36dab0f295ed)
@@ -2241,10 +3095,14 @@ class GitHubActionsProvider(
     jsii_struct_bases=[],
     name_mapping={
         "download_lfs": "downloadLfs",
+        "merge_queue": "mergeQueue",
+        "merge_queue_options": "mergeQueueOptions",
         "mergify": "mergify",
         "mergify_options": "mergifyOptions",
         "projen_credentials": "projenCredentials",
         "projen_token_secret": "projenTokenSecret",
+        "pull_request_backport": "pullRequestBackport",
+        "pull_request_backport_options": "pullRequestBackportOptions",
         "pull_request_lint": "pullRequestLint",
         "pull_request_lint_options": "pullRequestLintOptions",
         "workflows": "workflows",
@@ -2255,43 +3113,63 @@ class GitHubOptions:
         self,
         *,
         download_lfs: typing.Optional[builtins.bool] = None,
+        merge_queue: typing.Optional[builtins.bool] = None,
+        merge_queue_options: typing.Optional[typing.Union["MergeQueueOptions", typing.Dict[builtins.str, typing.Any]]] = None,
         mergify: typing.Optional[builtins.bool] = None,
         mergify_options: typing.Optional[typing.Union["MergifyOptions", typing.Dict[builtins.str, typing.Any]]] = None,
         projen_credentials: typing.Optional["GithubCredentials"] = None,
         projen_token_secret: typing.Optional[builtins.str] = None,
+        pull_request_backport: typing.Optional[builtins.bool] = None,
+        pull_request_backport_options: typing.Optional[typing.Union["PullRequestBackportOptions", typing.Dict[builtins.str, typing.Any]]] = None,
         pull_request_lint: typing.Optional[builtins.bool] = None,
         pull_request_lint_options: typing.Optional[typing.Union["PullRequestLintOptions", typing.Dict[builtins.str, typing.Any]]] = None,
         workflows: typing.Optional[builtins.bool] = None,
     ) -> None:
         '''
         :param download_lfs: (experimental) Download files in LFS in workflows. Default: true if the associated project has ``lfsPatterns``, ``false`` otherwise
+        :param merge_queue: (experimental) Whether a merge queue should be used on this repository to merge pull requests. Requires additional configuration of the repositories branch protection rules. Default: false
+        :param merge_queue_options: (experimental) Options for MergeQueue. Default: - default options
         :param mergify: (experimental) Whether mergify should be enabled on this repository or not. Default: true
         :param mergify_options: (experimental) Options for Mergify. Default: - default options
         :param projen_credentials: (experimental) Choose a method of providing GitHub API access for projen workflows. Default: - use a personal access token named PROJEN_GITHUB_TOKEN
         :param projen_token_secret: (deprecated) The name of a secret which includes a GitHub Personal Access Token to be used by projen workflows. This token needs to have the ``repo``, ``workflows`` and ``packages`` scope. Default: "PROJEN_GITHUB_TOKEN"
+        :param pull_request_backport: (experimental) Add a workflow that allows backport of PRs to other branches using labels. When opening a new PR add a backport label to it, and the PR will be backported to the target branches once the PR is merged. Should not be used together with mergify. Default: false
+        :param pull_request_backport_options: (experimental) Options for configuring pull request backport. Default: - see defaults in ``PullRequestBackportOptions``
         :param pull_request_lint: (experimental) Add a workflow that performs basic checks for pull requests, like validating that PRs follow Conventional Commits. Default: true
         :param pull_request_lint_options: (experimental) Options for configuring a pull request linter. Default: - see defaults in ``PullRequestLintOptions``
         :param workflows: (experimental) Enables GitHub workflows. If this is set to ``false``, workflows will not be created. Default: true
 
         :stability: experimental
         '''
+        if isinstance(merge_queue_options, dict):
+            merge_queue_options = MergeQueueOptions(**merge_queue_options)
         if isinstance(mergify_options, dict):
             mergify_options = MergifyOptions(**mergify_options)
+        if isinstance(pull_request_backport_options, dict):
+            pull_request_backport_options = PullRequestBackportOptions(**pull_request_backport_options)
         if isinstance(pull_request_lint_options, dict):
             pull_request_lint_options = PullRequestLintOptions(**pull_request_lint_options)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__c22e66f011c96f13a6f4e5b07bb676bf98b477678e968ee61f79ee107a7d2bd7)
             check_type(argname="argument download_lfs", value=download_lfs, expected_type=type_hints["download_lfs"])
+            check_type(argname="argument merge_queue", value=merge_queue, expected_type=type_hints["merge_queue"])
+            check_type(argname="argument merge_queue_options", value=merge_queue_options, expected_type=type_hints["merge_queue_options"])
             check_type(argname="argument mergify", value=mergify, expected_type=type_hints["mergify"])
             check_type(argname="argument mergify_options", value=mergify_options, expected_type=type_hints["mergify_options"])
             check_type(argname="argument projen_credentials", value=projen_credentials, expected_type=type_hints["projen_credentials"])
             check_type(argname="argument projen_token_secret", value=projen_token_secret, expected_type=type_hints["projen_token_secret"])
+            check_type(argname="argument pull_request_backport", value=pull_request_backport, expected_type=type_hints["pull_request_backport"])
+            check_type(argname="argument pull_request_backport_options", value=pull_request_backport_options, expected_type=type_hints["pull_request_backport_options"])
             check_type(argname="argument pull_request_lint", value=pull_request_lint, expected_type=type_hints["pull_request_lint"])
             check_type(argname="argument pull_request_lint_options", value=pull_request_lint_options, expected_type=type_hints["pull_request_lint_options"])
             check_type(argname="argument workflows", value=workflows, expected_type=type_hints["workflows"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
         if download_lfs is not None:
             self._values["download_lfs"] = download_lfs
+        if merge_queue is not None:
+            self._values["merge_queue"] = merge_queue
+        if merge_queue_options is not None:
+            self._values["merge_queue_options"] = merge_queue_options
         if mergify is not None:
             self._values["mergify"] = mergify
         if mergify_options is not None:
@@ -2300,6 +3178,10 @@ class GitHubOptions:
             self._values["projen_credentials"] = projen_credentials
         if projen_token_secret is not None:
             self._values["projen_token_secret"] = projen_token_secret
+        if pull_request_backport is not None:
+            self._values["pull_request_backport"] = pull_request_backport
+        if pull_request_backport_options is not None:
+            self._values["pull_request_backport_options"] = pull_request_backport_options
         if pull_request_lint is not None:
             self._values["pull_request_lint"] = pull_request_lint
         if pull_request_lint_options is not None:
@@ -2318,6 +3200,30 @@ class GitHubOptions:
         result = self._values.get("download_lfs")
         return typing.cast(typing.Optional[builtins.bool], result)
 
+    @builtins.property
+    def merge_queue(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Whether a merge queue should be used on this repository to merge pull requests.
+
+        Requires additional configuration of the repositories branch protection rules.
+
+        :default: false
+
+        :stability: experimental
+        '''
+        result = self._values.get("merge_queue")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def merge_queue_options(self) -> typing.Optional["MergeQueueOptions"]:
+        '''(experimental) Options for MergeQueue.
+
+        :default: - default options
+
+        :stability: experimental
+        '''
+        result = self._values.get("merge_queue_options")
+        return typing.cast(typing.Optional["MergeQueueOptions"], result)
+
     @builtins.property
     def mergify(self) -> typing.Optional[builtins.bool]:
         '''(experimental) Whether mergify should be enabled on this repository or not.
@@ -2367,6 +3273,35 @@ class GitHubOptions:
         result = self._values.get("projen_token_secret")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def pull_request_backport(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Add a workflow that allows backport of PRs to other branches using labels.
+
+        When opening a new PR add a backport label to it,
+        and the PR will be backported to the target branches once the PR is merged.
+
+        Should not be used together with mergify.
+
+        :default: false
+
+        :stability: experimental
+        '''
+        result = self._values.get("pull_request_backport")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def pull_request_backport_options(
+        self,
+    ) -> typing.Optional["PullRequestBackportOptions"]:
+        '''(experimental) Options for configuring pull request backport.
+
+        :default: - see defaults in ``PullRequestBackportOptions``
+
+        :stability: experimental
+        '''
+        result = self._values.get("pull_request_backport_options")
+        return typing.cast(typing.Optional["PullRequestBackportOptions"], result)
+
     @builtins.property
     def pull_request_lint(self) -> typing.Optional[builtins.bool]:
         '''(experimental) Add a workflow that performs basic checks for pull requests, like validating that PRs follow Conventional Commits.
@@ -3262,8 +4197,10 @@ class GithubCredentials(
         cls,
         *,
         app_id_secret: typing.Optional[builtins.str] = None,
+        owner: typing.Optional[builtins.str] = None,
         permissions: typing.Optional[typing.Union[_AppPermissions_59709d51, typing.Dict[builtins.str, typing.Any]]] = None,
         private_key_secret: typing.Optional[builtins.str] = None,
+        repositories: typing.Optional[typing.Sequence[builtins.str]] = None,
     ) -> "GithubCredentials":
         '''(experimental) Provide API access through a GitHub App.
 
@@ -3271,19 +4208,23 @@ class GithubCredentials(
         private key must be added as secrets to the repo. The name of the secrets
         can be specified here.
 
-        :param app_id_secret: 
+        :param app_id_secret: (experimental) The secret containing the GitHub App ID. Default: "PROJEN_APP_ID"
+        :param owner: (experimental) The owner of the GitHub App installation. Default: - if empty, defaults to the current repository owner
         :param permissions: (experimental) The permissions granted to the token. Default: - all permissions granted to the app
-        :param private_key_secret: 
+        :param private_key_secret: (experimental) The secret containing the GitHub App private key. Escaped newlines (\\n) will be automatically replaced with actual newlines. Default: "PROJEN_APP_PRIVATE_KEY"
+        :param repositories: (experimental) List of repositories to grant access to. Default: - if owner is set and repositories is empty, access will be scoped to all repositories in the provided repository owner's installation. If owner and repositories are empty, access will be scoped to only the current repository.
 
         :default: - app id stored in "PROJEN_APP_ID" and private key stored in "PROJEN_APP_PRIVATE_KEY" with all permissions attached to the app
 
-        :see: https://projen.io/github.html#github-app
+        :see: https://projen.io/docs/integrations/github/#github-app
         :stability: experimental
         '''
         options = GithubCredentialsAppOptions(
             app_id_secret=app_id_secret,
+            owner=owner,
             permissions=permissions,
             private_key_secret=private_key_secret,
+            repositories=repositories,
         )
 
         return typing.cast("GithubCredentials", jsii.sinvoke(cls, "fromApp", [options]))
@@ -3338,8 +4279,10 @@ class GithubCredentials(
     jsii_struct_bases=[],
     name_mapping={
         "app_id_secret": "appIdSecret",
+        "owner": "owner",
         "permissions": "permissions",
         "private_key_secret": "privateKeySecret",
+        "repositories": "repositories",
     },
 )
 class GithubCredentialsAppOptions:
@@ -3347,14 +4290,18 @@ class GithubCredentialsAppOptions:
         self,
         *,
         app_id_secret: typing.Optional[builtins.str] = None,
+        owner: typing.Optional[builtins.str] = None,
         permissions: typing.Optional[typing.Union[_AppPermissions_59709d51, typing.Dict[builtins.str, typing.Any]]] = None,
         private_key_secret: typing.Optional[builtins.str] = None,
+        repositories: typing.Optional[typing.Sequence[builtins.str]] = None,
     ) -> None:
         '''(experimental) Options for ``GithubCredentials.fromApp``.
 
-        :param app_id_secret: 
+        :param app_id_secret: (experimental) The secret containing the GitHub App ID. Default: "PROJEN_APP_ID"
+        :param owner: (experimental) The owner of the GitHub App installation. Default: - if empty, defaults to the current repository owner
         :param permissions: (experimental) The permissions granted to the token. Default: - all permissions granted to the app
-        :param private_key_secret: 
+        :param private_key_secret: (experimental) The secret containing the GitHub App private key. Escaped newlines (\\n) will be automatically replaced with actual newlines. Default: "PROJEN_APP_PRIVATE_KEY"
+        :param repositories: (experimental) List of repositories to grant access to. Default: - if owner is set and repositories is empty, access will be scoped to all repositories in the provided repository owner's installation. If owner and repositories are empty, access will be scoped to only the current repository.
 
         :stability: experimental
         '''
@@ -3363,24 +4310,44 @@ class GithubCredentialsAppOptions:
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__cfe552d6288d1f706792afe5f041e666db050b8d0d3bb7062899a3bdefe652a8)
             check_type(argname="argument app_id_secret", value=app_id_secret, expected_type=type_hints["app_id_secret"])
+            check_type(argname="argument owner", value=owner, expected_type=type_hints["owner"])
             check_type(argname="argument permissions", value=permissions, expected_type=type_hints["permissions"])
             check_type(argname="argument private_key_secret", value=private_key_secret, expected_type=type_hints["private_key_secret"])
+            check_type(argname="argument repositories", value=repositories, expected_type=type_hints["repositories"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
         if app_id_secret is not None:
             self._values["app_id_secret"] = app_id_secret
+        if owner is not None:
+            self._values["owner"] = owner
         if permissions is not None:
             self._values["permissions"] = permissions
         if private_key_secret is not None:
             self._values["private_key_secret"] = private_key_secret
+        if repositories is not None:
+            self._values["repositories"] = repositories
 
     @builtins.property
     def app_id_secret(self) -> typing.Optional[builtins.str]:
-        '''
+        '''(experimental) The secret containing the GitHub App ID.
+
+        :default: "PROJEN_APP_ID"
+
         :stability: experimental
         '''
         result = self._values.get("app_id_secret")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def owner(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The owner of the GitHub App installation.
+
+        :default: - if empty, defaults to the current repository owner
+
+        :stability: experimental
+        '''
+        result = self._values.get("owner")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def permissions(self) -> typing.Optional[_AppPermissions_59709d51]:
         '''(experimental) The permissions granted to the token.
@@ -3394,12 +4361,31 @@ class GithubCredentialsAppOptions:
 
     @builtins.property
     def private_key_secret(self) -> typing.Optional[builtins.str]:
-        '''
+        '''(experimental) The secret containing the GitHub App private key.
+
+        Escaped newlines (\\n) will be automatically replaced with actual newlines.
+
+        :default: "PROJEN_APP_PRIVATE_KEY"
+
         :stability: experimental
         '''
         result = self._values.get("private_key_secret")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def repositories(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) List of repositories to grant access to.
+
+        :default:
+
+        - if owner is set and repositories is empty, access will be scoped to all repositories in the provided repository owner's installation.
+        If owner and repositories are empty, access will be scoped to only the current repository.
+
+        :stability: experimental
+        '''
+        result = self._values.get("repositories")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -3470,14 +4456,20 @@ class GithubWorkflow(
         github: GitHub,
         name: builtins.str,
         *,
-        concurrency: typing.Optional[builtins.str] = None,
+        concurrency_options: typing.Optional[typing.Union[ConcurrencyOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+        env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        file_name: typing.Optional[builtins.str] = None,
         force: typing.Optional[builtins.bool] = None,
+        limit_concurrency: typing.Optional[builtins.bool] = None,
     ) -> None:
         '''
-        :param github: -
-        :param name: -
-        :param concurrency: (experimental) Concurrency ensures that only a single job or workflow using the same concurrency group will run at a time. Currently in beta. Default: - disabled
+        :param github: The GitHub component of the project this workflow belongs to.
+        :param name: The name of the workflow, displayed under the repository's "Actions" tab.
+        :param concurrency_options: (experimental) Concurrency ensures that only a single job or workflow using the same concurrency group will run at a time. Currently in beta. Default: - { group: ${{ github.workflow }}, cancelInProgress: false }
+        :param env: (experimental) Additional environment variables to set for the workflow. Default: - no additional environment variables
+        :param file_name: (experimental) Set a custom file name for the workflow definition file. Must include either a .yml or .yaml file extension. Use this option to set a file name for the workflow file, that is different than the display name. Default: - a path-safe version of the workflow name plus the .yml file ending, e.g. build.yml
         :param force: (experimental) Force the creation of the workflow even if ``workflows`` is disabled in ``GitHub``. Default: false
+        :param limit_concurrency: (experimental) Enable concurrency limitations. Use ``concurrencyOptions`` to configure specific non default values. Default: false
 
         :stability: experimental
         '''
@@ -3485,7 +4477,13 @@ class GithubWorkflow(
             type_hints = typing.get_type_hints(_typecheckingstub__ca4f375b4fda039fc4fb5b2f4ad26a9d1695085d170d2d76e6d720c7cc22d02a)
             check_type(argname="argument github", value=github, expected_type=type_hints["github"])
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
-        options = GithubWorkflowOptions(concurrency=concurrency, force=force)
+        options = GithubWorkflowOptions(
+            concurrency_options=concurrency_options,
+            env=env,
+            file_name=file_name,
+            force=force,
+            limit_concurrency=limit_concurrency,
+        )
 
         jsii.create(self.__class__, self, [github, name, options])
 
@@ -3697,7 +4695,7 @@ class GithubWorkflow(
         self,
         jobs: typing.Mapping[builtins.str, typing.Union[typing.Union[_JobCallingReusableWorkflow_12ad1018, typing.Dict[builtins.str, typing.Any]], typing.Union[_Job_20ffcf45, typing.Dict[builtins.str, typing.Any]]]],
     ) -> None:
-        '''(experimental) Updates jobs for this worklow Does a complete replace, it does not try to merge the jobs.
+        '''(experimental) Updates jobs for this workflow Does a complete replace, it does not try to merge the jobs.
 
         :param jobs: Jobs to update.
 
@@ -3708,11 +4706,28 @@ class GithubWorkflow(
             check_type(argname="argument jobs", value=jobs, expected_type=type_hints["jobs"])
         return typing.cast(None, jsii.invoke(self, "updateJobs", [jobs]))
 
+    @builtins.property
+    @jsii.member(jsii_name="jobs")
+    def jobs(
+        self,
+    ) -> typing.Mapping[builtins.str, typing.Union[_JobCallingReusableWorkflow_12ad1018, _Job_20ffcf45]]:
+        '''(experimental) All current jobs of the workflow.
+
+        This is a read-only copy, use the respective helper methods to add, update or remove jobs.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Mapping[builtins.str, typing.Union[_JobCallingReusableWorkflow_12ad1018, _Job_20ffcf45]], jsii.get(self, "jobs"))
+
     @builtins.property
     @jsii.member(jsii_name="name")
     def name(self) -> builtins.str:
         '''(experimental) The name of the workflow.
 
+        GitHub displays the names of your workflows under your repository's
+        "Actions" tab.
+
+        :see: https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions#name
         :stability: experimental
         '''
         return typing.cast(builtins.str, jsii.get(self, "name"))
@@ -3728,14 +4743,23 @@ class GithubWorkflow(
 
     @builtins.property
     @jsii.member(jsii_name="concurrency")
-    def concurrency(self) -> typing.Optional[builtins.str]:
-        '''(experimental) Concurrency ensures that only a single job or workflow using the same concurrency group will run at a time.
+    def concurrency(self) -> typing.Optional[ConcurrencyOptions]:
+        '''(experimental) The concurrency configuration of the workflow.
+
+        undefined means no concurrency limitations.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[ConcurrencyOptions], jsii.get(self, "concurrency"))
 
-        :default: disabled
+    @builtins.property
+    @jsii.member(jsii_name="env")
+    def env(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
+        '''(experimental) Additional environment variables to set for the workflow.
 
         :stability: experimental
         '''
-        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "concurrency"))
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], jsii.get(self, "env"))
 
     @builtins.property
     @jsii.member(jsii_name="file")
@@ -3772,62 +4796,312 @@ class GithubWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__a6273080200c7722c9774364ee8460bccd3337cd48edc420530ca75f7c2974d9)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "runName", value)
+        jsii.set(self, "runName", value) # pyright: ignore[reportArgumentType]
 
 
 @jsii.data_type(
     jsii_type="projen.github.GithubWorkflowOptions",
     jsii_struct_bases=[],
-    name_mapping={"concurrency": "concurrency", "force": "force"},
+    name_mapping={
+        "concurrency_options": "concurrencyOptions",
+        "env": "env",
+        "file_name": "fileName",
+        "force": "force",
+        "limit_concurrency": "limitConcurrency",
+    },
 )
 class GithubWorkflowOptions:
     def __init__(
         self,
         *,
-        concurrency: typing.Optional[builtins.str] = None,
+        concurrency_options: typing.Optional[typing.Union[ConcurrencyOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+        env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        file_name: typing.Optional[builtins.str] = None,
         force: typing.Optional[builtins.bool] = None,
+        limit_concurrency: typing.Optional[builtins.bool] = None,
     ) -> None:
         '''(experimental) Options for ``GithubWorkflow``.
 
-        :param concurrency: (experimental) Concurrency ensures that only a single job or workflow using the same concurrency group will run at a time. Currently in beta. Default: - disabled
+        :param concurrency_options: (experimental) Concurrency ensures that only a single job or workflow using the same concurrency group will run at a time. Currently in beta. Default: - { group: ${{ github.workflow }}, cancelInProgress: false }
+        :param env: (experimental) Additional environment variables to set for the workflow. Default: - no additional environment variables
+        :param file_name: (experimental) Set a custom file name for the workflow definition file. Must include either a .yml or .yaml file extension. Use this option to set a file name for the workflow file, that is different than the display name. Default: - a path-safe version of the workflow name plus the .yml file ending, e.g. build.yml
         :param force: (experimental) Force the creation of the workflow even if ``workflows`` is disabled in ``GitHub``. Default: false
+        :param limit_concurrency: (experimental) Enable concurrency limitations. Use ``concurrencyOptions`` to configure specific non default values. Default: false
 
         :stability: experimental
         '''
+        if isinstance(concurrency_options, dict):
+            concurrency_options = ConcurrencyOptions(**concurrency_options)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__c779b00d3df0cff3a9570cc6ed35339952399a898d5854423c3329b55bf736ec)
-            check_type(argname="argument concurrency", value=concurrency, expected_type=type_hints["concurrency"])
+            check_type(argname="argument concurrency_options", value=concurrency_options, expected_type=type_hints["concurrency_options"])
+            check_type(argname="argument env", value=env, expected_type=type_hints["env"])
+            check_type(argname="argument file_name", value=file_name, expected_type=type_hints["file_name"])
             check_type(argname="argument force", value=force, expected_type=type_hints["force"])
+            check_type(argname="argument limit_concurrency", value=limit_concurrency, expected_type=type_hints["limit_concurrency"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
-        if concurrency is not None:
-            self._values["concurrency"] = concurrency
+        if concurrency_options is not None:
+            self._values["concurrency_options"] = concurrency_options
+        if env is not None:
+            self._values["env"] = env
+        if file_name is not None:
+            self._values["file_name"] = file_name
         if force is not None:
             self._values["force"] = force
+        if limit_concurrency is not None:
+            self._values["limit_concurrency"] = limit_concurrency
+
+    @builtins.property
+    def concurrency_options(self) -> typing.Optional[ConcurrencyOptions]:
+        '''(experimental) Concurrency ensures that only a single job or workflow using the same concurrency group will run at a time.
+
+        Currently in beta.
+
+        :default: - { group: ${{ github.workflow }}, cancelInProgress: false }
+
+        :see: https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#concurrency
+        :stability: experimental
+        '''
+        result = self._values.get("concurrency_options")
+        return typing.cast(typing.Optional[ConcurrencyOptions], result)
+
+    @builtins.property
+    def env(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
+        '''(experimental) Additional environment variables to set for the workflow.
+
+        :default: - no additional environment variables
+
+        :stability: experimental
+        '''
+        result = self._values.get("env")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
+
+    @builtins.property
+    def file_name(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Set a custom file name for the workflow definition file. Must include either a .yml or .yaml file extension.
+
+        Use this option to set a file name for the workflow file, that is different than the display name.
+
+        :default: - a path-safe version of the workflow name plus the .yml file ending, e.g. build.yml
+
+        :stability: experimental
+
+        Example::
+
+            "my-workflow.yaml"
+        '''
+        result = self._values.get("file_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def force(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Force the creation of the workflow even if ``workflows`` is disabled in ``GitHub``.
+
+        :default: false
+
+        :stability: experimental
+        '''
+        result = self._values.get("force")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def limit_concurrency(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Enable concurrency limitations.
+
+        Use ``concurrencyOptions`` to configure specific non default values.
+
+        :default: false
+
+        :stability: experimental
+        '''
+        result = self._values.get("limit_concurrency")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "GithubWorkflowOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.interface(jsii_type="projen.github.IAddConditionsLater")
+class IAddConditionsLater(typing_extensions.Protocol):
+    '''
+    :stability: experimental
+    '''
+
+    @jsii.member(jsii_name="render")
+    def render(self) -> typing.List[builtins.str]:
+        '''
+        :stability: experimental
+        '''
+        ...
+
+
+class _IAddConditionsLaterProxy:
+    '''
+    :stability: experimental
+    '''
+
+    __jsii_type__: typing.ClassVar[str] = "projen.github.IAddConditionsLater"
+
+    @jsii.member(jsii_name="render")
+    def render(self) -> typing.List[builtins.str]:
+        '''
+        :stability: experimental
+        '''
+        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "render", []))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
+typing.cast(typing.Any, IAddConditionsLater).__jsii_proxy_class__ = lambda : _IAddConditionsLaterProxy
+
+
+@jsii.enum(jsii_type="projen.github.MergeMethod")
+class MergeMethod(enum.Enum):
+    '''(experimental) The merge method used to add the PR to the merge queue.
+
+    Behavior can be further configured in repository settings.
+
+    :stability: experimental
+    '''
+
+    SQUASH = "SQUASH"
+    '''
+    :stability: experimental
+    '''
+    MERGE = "MERGE"
+    '''
+    :stability: experimental
+    '''
+    REBASE = "REBASE"
+    '''
+    :stability: experimental
+    '''
+
+
+class MergeQueue(
+    _Component_2b0ad27f,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="projen.github.MergeQueue",
+):
+    '''(experimental) Merge pull requests using a merge queue.
+
+    :stability: experimental
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.IConstruct,
+        *,
+        auto_queue: typing.Optional[builtins.bool] = None,
+        auto_queue_options: typing.Optional[typing.Union[AutoQueueOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+        target_branches: typing.Optional[typing.Sequence[builtins.str]] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param auto_queue: (experimental) Should pull requests be queued automatically to be merged once they pass required checks. Default: true
+        :param auto_queue_options: (experimental) Configure auto-queue pull requests. Default: - see AutoQueueOptions
+        :param target_branches: (experimental) The branches that can be merged into using MergeQueue. Default: - all branches
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__8d0860f4805d4f3404f9b940157e555ab934aaea8c3deecc2681f63f23129dc7)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+        options = MergeQueueOptions(
+            auto_queue=auto_queue,
+            auto_queue_options=auto_queue_options,
+            target_branches=target_branches,
+        )
+
+        jsii.create(self.__class__, self, [scope, options])
+
+    @jsii.member(jsii_name="preSynthesize")
+    def pre_synthesize(self) -> None:
+        '''(experimental) Called before synthesis.
+
+        :stability: experimental
+        '''
+        return typing.cast(None, jsii.invoke(self, "preSynthesize", []))
+
+
+@jsii.data_type(
+    jsii_type="projen.github.MergeQueueOptions",
+    jsii_struct_bases=[],
+    name_mapping={
+        "auto_queue": "autoQueue",
+        "auto_queue_options": "autoQueueOptions",
+        "target_branches": "targetBranches",
+    },
+)
+class MergeQueueOptions:
+    def __init__(
+        self,
+        *,
+        auto_queue: typing.Optional[builtins.bool] = None,
+        auto_queue_options: typing.Optional[typing.Union[AutoQueueOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+        target_branches: typing.Optional[typing.Sequence[builtins.str]] = None,
+    ) -> None:
+        '''(experimental) Options for 'MergeQueue'.
+
+        :param auto_queue: (experimental) Should pull requests be queued automatically to be merged once they pass required checks. Default: true
+        :param auto_queue_options: (experimental) Configure auto-queue pull requests. Default: - see AutoQueueOptions
+        :param target_branches: (experimental) The branches that can be merged into using MergeQueue. Default: - all branches
+
+        :stability: experimental
+        '''
+        if isinstance(auto_queue_options, dict):
+            auto_queue_options = AutoQueueOptions(**auto_queue_options)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5ed41b74ffbee4fd52a12674b58bd68e113a707d7c3dec6e1ecb7f9647debbc3)
+            check_type(argname="argument auto_queue", value=auto_queue, expected_type=type_hints["auto_queue"])
+            check_type(argname="argument auto_queue_options", value=auto_queue_options, expected_type=type_hints["auto_queue_options"])
+            check_type(argname="argument target_branches", value=target_branches, expected_type=type_hints["target_branches"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if auto_queue is not None:
+            self._values["auto_queue"] = auto_queue
+        if auto_queue_options is not None:
+            self._values["auto_queue_options"] = auto_queue_options
+        if target_branches is not None:
+            self._values["target_branches"] = target_branches
+
+    @builtins.property
+    def auto_queue(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Should pull requests be queued automatically to be merged once they pass required checks.
+
+        :default: true
 
-    @builtins.property
-    def concurrency(self) -> typing.Optional[builtins.str]:
-        '''(experimental) Concurrency ensures that only a single job or workflow using the same concurrency group will run at a time.
+        :stability: experimental
+        '''
+        result = self._values.get("auto_queue")
+        return typing.cast(typing.Optional[builtins.bool], result)
 
-        Currently in beta.
+    @builtins.property
+    def auto_queue_options(self) -> typing.Optional[AutoQueueOptions]:
+        '''(experimental) Configure auto-queue pull requests.
 
-        :default: - disabled
+        :default: - see AutoQueueOptions
 
-        :see: https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#concurrency
         :stability: experimental
         '''
-        result = self._values.get("concurrency")
-        return typing.cast(typing.Optional[builtins.str], result)
+        result = self._values.get("auto_queue_options")
+        return typing.cast(typing.Optional[AutoQueueOptions], result)
 
     @builtins.property
-    def force(self) -> typing.Optional[builtins.bool]:
-        '''(experimental) Force the creation of the workflow even if ``workflows`` is disabled in ``GitHub``.
+    def target_branches(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) The branches that can be merged into using MergeQueue.
 
-        :default: false
+        :default: - all branches
 
         :stability: experimental
         '''
-        result = self._values.get("force")
-        return typing.cast(typing.Optional[builtins.bool], result)
+        result = self._values.get("target_branches")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
 
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -3836,43 +5110,11 @@ class GithubWorkflowOptions:
         return not (rhs == self)
 
     def __repr__(self) -> str:
-        return "GithubWorkflowOptions(%s)" % ", ".join(
+        return "MergeQueueOptions(%s)" % ", ".join(
             k + "=" + repr(v) for k, v in self._values.items()
         )
 
 
-@jsii.interface(jsii_type="projen.github.IAddConditionsLater")
-class IAddConditionsLater(typing_extensions.Protocol):
-    '''
-    :stability: experimental
-    '''
-
-    @jsii.member(jsii_name="render")
-    def render(self) -> typing.List[builtins.str]:
-        '''
-        :stability: experimental
-        '''
-        ...
-
-
-class _IAddConditionsLaterProxy:
-    '''
-    :stability: experimental
-    '''
-
-    __jsii_type__: typing.ClassVar[str] = "projen.github.IAddConditionsLater"
-
-    @jsii.member(jsii_name="render")
-    def render(self) -> typing.List[builtins.str]:
-        '''
-        :stability: experimental
-        '''
-        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "render", []))
-
-# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
-typing.cast(typing.Any, IAddConditionsLater).__jsii_proxy_class__ = lambda : _IAddConditionsLaterProxy
-
-
 class Mergify(
     _Component_2b0ad27f,
     metaclass=jsii.JSIIMeta,
@@ -3891,8 +5133,8 @@ class Mergify(
     ) -> None:
         '''
         :param github: -
-        :param queues: 
-        :param rules: 
+        :param queues: (experimental) The available merge queues.
+        :param rules: (experimental) Pull request automation rules.
 
         :stability: experimental
         '''
@@ -3907,23 +5149,32 @@ class Mergify(
     def add_queue(
         self,
         *,
-        conditions: typing.Sequence[typing.Union[builtins.str, typing.Union["MergifyConditionalOperator", typing.Dict[builtins.str, typing.Any]]]],
+        commit_message_template: builtins.str,
         name: builtins.str,
+        conditions: typing.Optional[typing.Sequence[typing.Union[builtins.str, typing.Union["MergifyConditionalOperator", typing.Dict[builtins.str, typing.Any]]]]] = None,
+        merge_conditions: typing.Optional[typing.Sequence[typing.Union[builtins.str, typing.Union["MergifyConditionalOperator", typing.Dict[builtins.str, typing.Any]]]]] = None,
         merge_method: typing.Optional[builtins.str] = None,
+        queue_conditions: typing.Optional[typing.Sequence[typing.Union[builtins.str, typing.Union["MergifyConditionalOperator", typing.Dict[builtins.str, typing.Any]]]]] = None,
         update_method: typing.Optional[builtins.str] = None,
     ) -> None:
         '''
-        :param conditions: (experimental) A list of Conditions string that must match against the pull request for the pull request to be added to the queue.
+        :param commit_message_template: (experimental) Template to use as the commit message when using the merge or squash merge method.
         :param name: (experimental) The name of the queue.
+        :param conditions: (deprecated) The list of conditions that needs to match to queue the pull request.
+        :param merge_conditions: (experimental) The list of conditions to match to get the queued pull request merged. This automatically includes the queueConditions. In case of speculative merge pull request, the merge conditions are evaluated against the temporary pull request instead of the original one.
         :param merge_method: (experimental) Merge method to use. Possible values are ``merge``, ``squash``, ``rebase`` or ``fast-forward``. ``fast-forward`` is not supported on queues with ``speculative_checks`` > 1, ``batch_size`` > 1, or with ``allow_inplace_checks`` set to false. Default: "merge"
+        :param queue_conditions: (experimental) The list of conditions that needs to match to queue the pull request.
         :param update_method: (experimental) Method to use to update the pull request with its base branch when the speculative check is done in-place. Possible values: - ``merge`` to merge the base branch into the pull request. - ``rebase`` to rebase the pull request against its base branch. Note that the ``rebase`` method has some drawbacks, see Mergify docs for details. Default: - ``merge`` for all merge methods except ``fast-forward`` where ``rebase`` is used
 
         :stability: experimental
         '''
         queue = MergifyQueue(
-            conditions=conditions,
+            commit_message_template=commit_message_template,
             name=name,
+            conditions=conditions,
+            merge_conditions=merge_conditions,
             merge_method=merge_method,
+            queue_conditions=queue_conditions,
             update_method=update_method,
         )
 
@@ -4025,10 +5276,14 @@ class MergifyOptions:
         queues: typing.Optional[typing.Sequence[typing.Union["MergifyQueue", typing.Dict[builtins.str, typing.Any]]]] = None,
         rules: typing.Optional[typing.Sequence[typing.Union["MergifyRule", typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
-        '''
-        :param queues: 
-        :param rules: 
+        '''(experimental) Configure Mergify.
 
+        This currently only offers a subset of options available.
+
+        :param queues: (experimental) The available merge queues.
+        :param rules: (experimental) Pull request automation rules.
+
+        :see: https://docs.mergify.com/configuration/file-format/
         :stability: experimental
         '''
         if __debug__:
@@ -4043,7 +5298,8 @@ class MergifyOptions:
 
     @builtins.property
     def queues(self) -> typing.Optional[typing.List["MergifyQueue"]]:
-        '''
+        '''(experimental) The available merge queues.
+
         :stability: experimental
         '''
         result = self._values.get("queues")
@@ -4051,7 +5307,8 @@ class MergifyOptions:
 
     @builtins.property
     def rules(self) -> typing.Optional[typing.List["MergifyRule"]]:
-        '''
+        '''(experimental) Pull request automation rules.
+
         :stability: experimental
         '''
         result = self._values.get("rules")
@@ -4073,9 +5330,12 @@ class MergifyOptions:
     jsii_type="projen.github.MergifyQueue",
     jsii_struct_bases=[],
     name_mapping={
-        "conditions": "conditions",
+        "commit_message_template": "commitMessageTemplate",
         "name": "name",
+        "conditions": "conditions",
+        "merge_conditions": "mergeConditions",
         "merge_method": "mergeMethod",
+        "queue_conditions": "queueConditions",
         "update_method": "updateMethod",
     },
 )
@@ -4083,46 +5343,58 @@ class MergifyQueue:
     def __init__(
         self,
         *,
-        conditions: typing.Sequence[typing.Union[builtins.str, typing.Union[MergifyConditionalOperator, typing.Dict[builtins.str, typing.Any]]]],
+        commit_message_template: builtins.str,
         name: builtins.str,
+        conditions: typing.Optional[typing.Sequence[typing.Union[builtins.str, typing.Union[MergifyConditionalOperator, typing.Dict[builtins.str, typing.Any]]]]] = None,
+        merge_conditions: typing.Optional[typing.Sequence[typing.Union[builtins.str, typing.Union[MergifyConditionalOperator, typing.Dict[builtins.str, typing.Any]]]]] = None,
         merge_method: typing.Optional[builtins.str] = None,
+        queue_conditions: typing.Optional[typing.Sequence[typing.Union[builtins.str, typing.Union[MergifyConditionalOperator, typing.Dict[builtins.str, typing.Any]]]]] = None,
         update_method: typing.Optional[builtins.str] = None,
     ) -> None:
         '''
-        :param conditions: (experimental) A list of Conditions string that must match against the pull request for the pull request to be added to the queue.
+        :param commit_message_template: (experimental) Template to use as the commit message when using the merge or squash merge method.
         :param name: (experimental) The name of the queue.
+        :param conditions: (deprecated) The list of conditions that needs to match to queue the pull request.
+        :param merge_conditions: (experimental) The list of conditions to match to get the queued pull request merged. This automatically includes the queueConditions. In case of speculative merge pull request, the merge conditions are evaluated against the temporary pull request instead of the original one.
         :param merge_method: (experimental) Merge method to use. Possible values are ``merge``, ``squash``, ``rebase`` or ``fast-forward``. ``fast-forward`` is not supported on queues with ``speculative_checks`` > 1, ``batch_size`` > 1, or with ``allow_inplace_checks`` set to false. Default: "merge"
+        :param queue_conditions: (experimental) The list of conditions that needs to match to queue the pull request.
         :param update_method: (experimental) Method to use to update the pull request with its base branch when the speculative check is done in-place. Possible values: - ``merge`` to merge the base branch into the pull request. - ``rebase`` to rebase the pull request against its base branch. Note that the ``rebase`` method has some drawbacks, see Mergify docs for details. Default: - ``merge`` for all merge methods except ``fast-forward`` where ``rebase`` is used
 
         :stability: experimental
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__0471efd0a49bc64e556512e765a1df23d4a975f26cb6de765579b4173907f467)
-            check_type(argname="argument conditions", value=conditions, expected_type=type_hints["conditions"])
+            check_type(argname="argument commit_message_template", value=commit_message_template, expected_type=type_hints["commit_message_template"])
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument conditions", value=conditions, expected_type=type_hints["conditions"])
+            check_type(argname="argument merge_conditions", value=merge_conditions, expected_type=type_hints["merge_conditions"])
             check_type(argname="argument merge_method", value=merge_method, expected_type=type_hints["merge_method"])
+            check_type(argname="argument queue_conditions", value=queue_conditions, expected_type=type_hints["queue_conditions"])
             check_type(argname="argument update_method", value=update_method, expected_type=type_hints["update_method"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
-            "conditions": conditions,
+            "commit_message_template": commit_message_template,
             "name": name,
         }
+        if conditions is not None:
+            self._values["conditions"] = conditions
+        if merge_conditions is not None:
+            self._values["merge_conditions"] = merge_conditions
         if merge_method is not None:
             self._values["merge_method"] = merge_method
+        if queue_conditions is not None:
+            self._values["queue_conditions"] = queue_conditions
         if update_method is not None:
             self._values["update_method"] = update_method
 
     @builtins.property
-    def conditions(
-        self,
-    ) -> typing.List[typing.Union[builtins.str, MergifyConditionalOperator]]:
-        '''(experimental) A list of Conditions string that must match against the pull request for the pull request to be added to the queue.
+    def commit_message_template(self) -> builtins.str:
+        '''(experimental) Template to use as the commit message when using the merge or squash merge method.
 
-        :see: https://docs.mergify.com/conditions/#conditions
         :stability: experimental
         '''
-        result = self._values.get("conditions")
-        assert result is not None, "Required property 'conditions' is missing"
-        return typing.cast(typing.List[typing.Union[builtins.str, MergifyConditionalOperator]], result)
+        result = self._values.get("commit_message_template")
+        assert result is not None, "Required property 'commit_message_template' is missing"
+        return typing.cast(builtins.str, result)
 
     @builtins.property
     def name(self) -> builtins.str:
@@ -4134,6 +5406,35 @@ class MergifyQueue:
         assert result is not None, "Required property 'name' is missing"
         return typing.cast(builtins.str, result)
 
+    @builtins.property
+    def conditions(
+        self,
+    ) -> typing.Optional[typing.List[typing.Union[builtins.str, MergifyConditionalOperator]]]:
+        '''(deprecated) The list of conditions that needs to match to queue the pull request.
+
+        :deprecated: use ``queueConditions`` instead
+
+        :see: https://docs.mergify.com/configuration/file-format/#queue-rules
+        :stability: deprecated
+        '''
+        result = self._values.get("conditions")
+        return typing.cast(typing.Optional[typing.List[typing.Union[builtins.str, MergifyConditionalOperator]]], result)
+
+    @builtins.property
+    def merge_conditions(
+        self,
+    ) -> typing.Optional[typing.List[typing.Union[builtins.str, MergifyConditionalOperator]]]:
+        '''(experimental) The list of conditions to match to get the queued pull request merged.
+
+        This automatically includes the queueConditions.
+        In case of speculative merge pull request, the merge conditions are evaluated against the temporary pull request instead of the original one.
+
+        :see: https://docs.mergify.com/conditions/#conditions
+        :stability: experimental
+        '''
+        result = self._values.get("merge_conditions")
+        return typing.cast(typing.Optional[typing.List[typing.Union[builtins.str, MergifyConditionalOperator]]], result)
+
     @builtins.property
     def merge_method(self) -> typing.Optional[builtins.str]:
         '''(experimental) Merge method to use.
@@ -4148,104 +5449,336 @@ class MergifyQueue:
         result = self._values.get("merge_method")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def queue_conditions(
+        self,
+    ) -> typing.Optional[typing.List[typing.Union[builtins.str, MergifyConditionalOperator]]]:
+        '''(experimental) The list of conditions that needs to match to queue the pull request.
+
+        :see: https://docs.mergify.com/conditions/#conditions
+        :stability: experimental
+        '''
+        result = self._values.get("queue_conditions")
+        return typing.cast(typing.Optional[typing.List[typing.Union[builtins.str, MergifyConditionalOperator]]], result)
+
     @builtins.property
     def update_method(self) -> typing.Optional[builtins.str]:
         '''(experimental) Method to use to update the pull request with its base branch when the speculative check is done in-place.
 
-        Possible values:
+        Possible values:
+
+        - ``merge`` to merge the base branch into the pull request.
+        - ``rebase`` to rebase the pull request against its base branch.
+
+        Note that the ``rebase`` method has some drawbacks, see Mergify docs for details.
+
+        :default: - ``merge`` for all merge methods except ``fast-forward`` where ``rebase`` is used
+
+        :see: https://docs.mergify.com/actions/queue/#queue-rules
+        :stability: experimental
+        '''
+        result = self._values.get("update_method")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "MergifyQueue(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="projen.github.MergifyRule",
+    jsii_struct_bases=[],
+    name_mapping={"actions": "actions", "conditions": "conditions", "name": "name"},
+)
+class MergifyRule:
+    def __init__(
+        self,
+        *,
+        actions: typing.Mapping[builtins.str, typing.Any],
+        conditions: typing.Sequence[typing.Union[builtins.str, typing.Union[MergifyConditionalOperator, typing.Dict[builtins.str, typing.Any]]]],
+        name: builtins.str,
+    ) -> None:
+        '''
+        :param actions: (experimental) A dictionary made of Actions that will be executed on the matching pull requests.
+        :param conditions: (experimental) A list of Conditions string that must match against the pull request for the rule to be applied.
+        :param name: (experimental) The name of the rule. This is not used by the engine directly, but is used when reporting information about a rule.
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__95405391335691b357d88cc73d37d1ee20fceae6cf671811812f639729b5accd)
+            check_type(argname="argument actions", value=actions, expected_type=type_hints["actions"])
+            check_type(argname="argument conditions", value=conditions, expected_type=type_hints["conditions"])
+            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "actions": actions,
+            "conditions": conditions,
+            "name": name,
+        }
+
+    @builtins.property
+    def actions(self) -> typing.Mapping[builtins.str, typing.Any]:
+        '''(experimental) A dictionary made of Actions that will be executed on the matching pull requests.
+
+        :see: https://docs.mergify.io/actions/#actions
+        :stability: experimental
+        '''
+        result = self._values.get("actions")
+        assert result is not None, "Required property 'actions' is missing"
+        return typing.cast(typing.Mapping[builtins.str, typing.Any], result)
+
+    @builtins.property
+    def conditions(
+        self,
+    ) -> typing.List[typing.Union[builtins.str, MergifyConditionalOperator]]:
+        '''(experimental) A list of Conditions string that must match against the pull request for the rule to be applied.
+
+        :see: https://docs.mergify.io/conditions/#conditions
+        :stability: experimental
+        '''
+        result = self._values.get("conditions")
+        assert result is not None, "Required property 'conditions' is missing"
+        return typing.cast(typing.List[typing.Union[builtins.str, MergifyConditionalOperator]], result)
+
+    @builtins.property
+    def name(self) -> builtins.str:
+        '''(experimental) The name of the rule.
+
+        This is not used by the engine directly,
+        but is used when reporting information about a rule.
+
+        :stability: experimental
+        '''
+        result = self._values.get("name")
+        assert result is not None, "Required property 'name' is missing"
+        return typing.cast(builtins.str, result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "MergifyRule(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+class PullRequestBackport(
+    _Component_2b0ad27f,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="projen.github.PullRequestBackport",
+):
+    '''
+    :stability: experimental
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.IConstruct,
+        *,
+        auto_approve_backport: typing.Optional[builtins.bool] = None,
+        backport_branch_name_prefix: typing.Optional[builtins.str] = None,
+        backport_pr_labels: typing.Optional[typing.Sequence[builtins.str]] = None,
+        branches: typing.Optional[typing.Sequence[builtins.str]] = None,
+        create_with_conflicts: typing.Optional[builtins.bool] = None,
+        label_prefix: typing.Optional[builtins.str] = None,
+        workflow_name: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param auto_approve_backport: (experimental) Automatically approve backport PRs if the 'auto approve' workflow is available. Default: true
+        :param backport_branch_name_prefix: (experimental) The prefix used to name backport branches. Make sure to include a separator at the end like ``/`` or ``_``. Default: "backport/"
+        :param backport_pr_labels: (experimental) The labels added to the created backport PR. Default: ["backport"]
+        :param branches: (experimental) List of branches that can be a target for backports. Default: - allow backports to all release branches
+        :param create_with_conflicts: (experimental) Should this created Backport PRs with conflicts. Conflicts will have to be resolved manually, but a PR is always created. Set to ``false`` to prevent the backport PR from being created if there are conflicts. Default: true
+        :param label_prefix: (experimental) The prefix used to detect PRs that should be backported. Default: "backport-to-"
+        :param workflow_name: (experimental) The name of the workflow. Default: "backport"
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__a321227b5ffc19f1220367db19ad9a6c84aec3e2bf74ba19db5a89f3ee8c9ce4)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+        options = PullRequestBackportOptions(
+            auto_approve_backport=auto_approve_backport,
+            backport_branch_name_prefix=backport_branch_name_prefix,
+            backport_pr_labels=backport_pr_labels,
+            branches=branches,
+            create_with_conflicts=create_with_conflicts,
+            label_prefix=label_prefix,
+            workflow_name=workflow_name,
+        )
+
+        jsii.create(self.__class__, self, [scope, options])
+
+    @builtins.property
+    @jsii.member(jsii_name="file")
+    def file(self) -> _JsonFile_fa8164db:
+        '''
+        :stability: experimental
+        '''
+        return typing.cast(_JsonFile_fa8164db, jsii.get(self, "file"))
+
+    @builtins.property
+    @jsii.member(jsii_name="workflow")
+    def workflow(self) -> GithubWorkflow:
+        '''
+        :stability: experimental
+        '''
+        return typing.cast(GithubWorkflow, jsii.get(self, "workflow"))
+
+
+@jsii.data_type(
+    jsii_type="projen.github.PullRequestBackportOptions",
+    jsii_struct_bases=[],
+    name_mapping={
+        "auto_approve_backport": "autoApproveBackport",
+        "backport_branch_name_prefix": "backportBranchNamePrefix",
+        "backport_pr_labels": "backportPRLabels",
+        "branches": "branches",
+        "create_with_conflicts": "createWithConflicts",
+        "label_prefix": "labelPrefix",
+        "workflow_name": "workflowName",
+    },
+)
+class PullRequestBackportOptions:
+    def __init__(
+        self,
+        *,
+        auto_approve_backport: typing.Optional[builtins.bool] = None,
+        backport_branch_name_prefix: typing.Optional[builtins.str] = None,
+        backport_pr_labels: typing.Optional[typing.Sequence[builtins.str]] = None,
+        branches: typing.Optional[typing.Sequence[builtins.str]] = None,
+        create_with_conflicts: typing.Optional[builtins.bool] = None,
+        label_prefix: typing.Optional[builtins.str] = None,
+        workflow_name: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''
+        :param auto_approve_backport: (experimental) Automatically approve backport PRs if the 'auto approve' workflow is available. Default: true
+        :param backport_branch_name_prefix: (experimental) The prefix used to name backport branches. Make sure to include a separator at the end like ``/`` or ``_``. Default: "backport/"
+        :param backport_pr_labels: (experimental) The labels added to the created backport PR. Default: ["backport"]
+        :param branches: (experimental) List of branches that can be a target for backports. Default: - allow backports to all release branches
+        :param create_with_conflicts: (experimental) Should this created Backport PRs with conflicts. Conflicts will have to be resolved manually, but a PR is always created. Set to ``false`` to prevent the backport PR from being created if there are conflicts. Default: true
+        :param label_prefix: (experimental) The prefix used to detect PRs that should be backported. Default: "backport-to-"
+        :param workflow_name: (experimental) The name of the workflow. Default: "backport"
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__066696cdba0d516ea035e9580a9e5c79c5a552ca23f78e5291d21811124a2a62)
+            check_type(argname="argument auto_approve_backport", value=auto_approve_backport, expected_type=type_hints["auto_approve_backport"])
+            check_type(argname="argument backport_branch_name_prefix", value=backport_branch_name_prefix, expected_type=type_hints["backport_branch_name_prefix"])
+            check_type(argname="argument backport_pr_labels", value=backport_pr_labels, expected_type=type_hints["backport_pr_labels"])
+            check_type(argname="argument branches", value=branches, expected_type=type_hints["branches"])
+            check_type(argname="argument create_with_conflicts", value=create_with_conflicts, expected_type=type_hints["create_with_conflicts"])
+            check_type(argname="argument label_prefix", value=label_prefix, expected_type=type_hints["label_prefix"])
+            check_type(argname="argument workflow_name", value=workflow_name, expected_type=type_hints["workflow_name"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if auto_approve_backport is not None:
+            self._values["auto_approve_backport"] = auto_approve_backport
+        if backport_branch_name_prefix is not None:
+            self._values["backport_branch_name_prefix"] = backport_branch_name_prefix
+        if backport_pr_labels is not None:
+            self._values["backport_pr_labels"] = backport_pr_labels
+        if branches is not None:
+            self._values["branches"] = branches
+        if create_with_conflicts is not None:
+            self._values["create_with_conflicts"] = create_with_conflicts
+        if label_prefix is not None:
+            self._values["label_prefix"] = label_prefix
+        if workflow_name is not None:
+            self._values["workflow_name"] = workflow_name
+
+    @builtins.property
+    def auto_approve_backport(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Automatically approve backport PRs if the 'auto approve' workflow is available.
+
+        :default: true
+
+        :stability: experimental
+        '''
+        result = self._values.get("auto_approve_backport")
+        return typing.cast(typing.Optional[builtins.bool], result)
 
-        - ``merge`` to merge the base branch into the pull request.
-        - ``rebase`` to rebase the pull request against its base branch.
+    @builtins.property
+    def backport_branch_name_prefix(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The prefix used to name backport branches.
 
-        Note that the ``rebase`` method has some drawbacks, see Mergify docs for details.
+        Make sure to include a separator at the end like ``/`` or ``_``.
 
-        :default: - ``merge`` for all merge methods except ``fast-forward`` where ``rebase`` is used
+        :default: "backport/"
 
-        :see: https://docs.mergify.com/actions/queue/#queue-rules
         :stability: experimental
         '''
-        result = self._values.get("update_method")
+        result = self._values.get("backport_branch_name_prefix")
         return typing.cast(typing.Optional[builtins.str], result)
 
-    def __eq__(self, rhs: typing.Any) -> builtins.bool:
-        return isinstance(rhs, self.__class__) and rhs._values == self._values
+    @builtins.property
+    def backport_pr_labels(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) The labels added to the created backport PR.
 
-    def __ne__(self, rhs: typing.Any) -> builtins.bool:
-        return not (rhs == self)
+        :default: ["backport"]
 
-    def __repr__(self) -> str:
-        return "MergifyQueue(%s)" % ", ".join(
-            k + "=" + repr(v) for k, v in self._values.items()
-        )
+        :stability: experimental
+        '''
+        result = self._values.get("backport_pr_labels")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
 
+    @builtins.property
+    def branches(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) List of branches that can be a target for backports.
 
-@jsii.data_type(
-    jsii_type="projen.github.MergifyRule",
-    jsii_struct_bases=[],
-    name_mapping={"actions": "actions", "conditions": "conditions", "name": "name"},
-)
-class MergifyRule:
-    def __init__(
-        self,
-        *,
-        actions: typing.Mapping[builtins.str, typing.Any],
-        conditions: typing.Sequence[typing.Union[builtins.str, typing.Union[MergifyConditionalOperator, typing.Dict[builtins.str, typing.Any]]]],
-        name: builtins.str,
-    ) -> None:
-        '''
-        :param actions: (experimental) A dictionary made of Actions that will be executed on the matching pull requests.
-        :param conditions: (experimental) A list of Conditions string that must match against the pull request for the rule to be applied.
-        :param name: (experimental) The name of the rule. This is not used by the engine directly, but is used when reporting information about a rule.
+        :default: - allow backports to all release branches
 
         :stability: experimental
         '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__95405391335691b357d88cc73d37d1ee20fceae6cf671811812f639729b5accd)
-            check_type(argname="argument actions", value=actions, expected_type=type_hints["actions"])
-            check_type(argname="argument conditions", value=conditions, expected_type=type_hints["conditions"])
-            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
-        self._values: typing.Dict[builtins.str, typing.Any] = {
-            "actions": actions,
-            "conditions": conditions,
-            "name": name,
-        }
+        result = self._values.get("branches")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
 
     @builtins.property
-    def actions(self) -> typing.Mapping[builtins.str, typing.Any]:
-        '''(experimental) A dictionary made of Actions that will be executed on the matching pull requests.
+    def create_with_conflicts(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Should this created Backport PRs with conflicts.
+
+        Conflicts will have to be resolved manually, but a PR is always created.
+        Set to ``false`` to prevent the backport PR from being created if there are conflicts.
+
+        :default: true
 
-        :see: https://docs.mergify.io/actions/#actions
         :stability: experimental
         '''
-        result = self._values.get("actions")
-        assert result is not None, "Required property 'actions' is missing"
-        return typing.cast(typing.Mapping[builtins.str, typing.Any], result)
+        result = self._values.get("create_with_conflicts")
+        return typing.cast(typing.Optional[builtins.bool], result)
 
     @builtins.property
-    def conditions(
-        self,
-    ) -> typing.List[typing.Union[builtins.str, MergifyConditionalOperator]]:
-        '''(experimental) A list of Conditions string that must match against the pull request for the rule to be applied.
+    def label_prefix(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The prefix used to detect PRs that should be backported.
+
+        :default: "backport-to-"
 
-        :see: https://docs.mergify.io/conditions/#conditions
         :stability: experimental
         '''
-        result = self._values.get("conditions")
-        assert result is not None, "Required property 'conditions' is missing"
-        return typing.cast(typing.List[typing.Union[builtins.str, MergifyConditionalOperator]], result)
+        result = self._values.get("label_prefix")
+        return typing.cast(typing.Optional[builtins.str], result)
 
     @builtins.property
-    def name(self) -> builtins.str:
-        '''(experimental) The name of the rule.
+    def workflow_name(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The name of the workflow.
 
-        This is not used by the engine directly,
-        but is used when reporting information about a rule.
+        :default: "backport"
 
         :stability: experimental
         '''
-        result = self._values.get("name")
-        assert result is not None, "Required property 'name' is missing"
-        return typing.cast(builtins.str, result)
+        result = self._values.get("workflow_name")
+        return typing.cast(typing.Optional[builtins.str], result)
 
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -4254,7 +5787,7 @@ class MergifyRule:
         return not (rhs == self)
 
     def __repr__(self) -> str:
-        return "MergifyRule(%s)" % ", ".join(
+        return "PullRequestBackportOptions(%s)" % ", ".join(
             k + "=" + repr(v) for k, v in self._values.items()
         )
 
@@ -4310,7 +5843,7 @@ class PullRequestFromPatchOptions(CreatePullRequestOptions):
         :param base_branch: (experimental) Sets the pull request base branch. Default: - The branch checked out in the workflow.
         :param branch_name: (experimental) The pull request branch name. Default: ``github-actions/${options.workflowName}``
         :param credentials: (experimental) The job credentials used to create the pull request. Provided credentials must have permissions to create a pull request on the repository.
-        :param git_identity: (experimental) The git identity used to create the commit. Default: - the default github-actions user
+        :param git_identity: (experimental) The git identity used to create the commit. Default: - default GitHub Actions user
         :param labels: (experimental) Labels to apply on the PR. Default: - no labels.
         :param signoff: (experimental) Add Signed-off-by line by the committer at the end of the commit log message. Default: true
         :param step_id: (experimental) The step ID which produces the output which indicates if a patch was created. Default: "create_pr"
@@ -4459,7 +5992,7 @@ class PullRequestFromPatchOptions(CreatePullRequestOptions):
     def git_identity(self) -> typing.Optional[GitIdentity]:
         '''(experimental) The git identity used to create the commit.
 
-        :default: - the default github-actions user
+        :default: - default GitHub Actions user
 
         :stability: experimental
         '''
@@ -4779,6 +6312,7 @@ class PullRequestLintOptions:
     name_mapping={
         "fetch_depth": "fetchDepth",
         "lfs": "lfs",
+        "path": "path",
         "ref": "ref",
         "repository": "repository",
         "token": "token",
@@ -4793,6 +6327,7 @@ class PullRequestPatchSource(CheckoutWithPatchOptions):
         *,
         fetch_depth: typing.Optional[jsii.Number] = None,
         lfs: typing.Optional[builtins.bool] = None,
+        path: typing.Optional[builtins.str] = None,
         ref: typing.Optional[builtins.str] = None,
         repository: typing.Optional[builtins.str] = None,
         token: typing.Optional[builtins.str] = None,
@@ -4803,6 +6338,7 @@ class PullRequestPatchSource(CheckoutWithPatchOptions):
         '''
         :param fetch_depth: (experimental) Number of commits to fetch. 0 indicates all history for all branches and tags. Default: 1
         :param lfs: (experimental) Whether LFS is enabled for the GitHub repository. Default: false
+        :param path: (experimental) Relative path under $GITHUB_WORKSPACE to place the repository. Default: - $GITHUB_WORKSPACE
         :param ref: (experimental) Branch or tag name. Default: - the default branch is implicitly used
         :param repository: (experimental) The repository (owner/repo) to use. Default: - the default repository is implicitly used
         :param token: (experimental) A GitHub token to use when checking out the repository. If the intent is to push changes back to the branch, then you must use a PAT with ``repo`` (and possibly ``workflows``) permissions. Default: - the default GITHUB_TOKEN is implicitly used
@@ -4816,6 +6352,7 @@ class PullRequestPatchSource(CheckoutWithPatchOptions):
             type_hints = typing.get_type_hints(_typecheckingstub__c3c9a28aa8266154d9a36adad571b3695e958b931e79b9eaff4a7dc55e95dec8)
             check_type(argname="argument fetch_depth", value=fetch_depth, expected_type=type_hints["fetch_depth"])
             check_type(argname="argument lfs", value=lfs, expected_type=type_hints["lfs"])
+            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
             check_type(argname="argument ref", value=ref, expected_type=type_hints["ref"])
             check_type(argname="argument repository", value=repository, expected_type=type_hints["repository"])
             check_type(argname="argument token", value=token, expected_type=type_hints["token"])
@@ -4830,6 +6367,8 @@ class PullRequestPatchSource(CheckoutWithPatchOptions):
             self._values["fetch_depth"] = fetch_depth
         if lfs is not None:
             self._values["lfs"] = lfs
+        if path is not None:
+            self._values["path"] = path
         if ref is not None:
             self._values["ref"] = ref
         if repository is not None:
@@ -4863,6 +6402,17 @@ class PullRequestPatchSource(CheckoutWithPatchOptions):
         result = self._values.get("lfs")
         return typing.cast(typing.Optional[builtins.bool], result)
 
+    @builtins.property
+    def path(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Relative path under $GITHUB_WORKSPACE to place the repository.
+
+        :default: - $GITHUB_WORKSPACE
+
+        :stability: experimental
+        '''
+        result = self._values.get("path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def ref(self) -> typing.Optional[builtins.str]:
         '''(experimental) Branch or tag name.
@@ -5040,18 +6590,24 @@ class PullRequestTemplateOptions:
 @jsii.data_type(
     jsii_type="projen.github.SemanticTitleOptions",
     jsii_struct_bases=[],
-    name_mapping={"require_scope": "requireScope", "types": "types"},
+    name_mapping={
+        "require_scope": "requireScope",
+        "scopes": "scopes",
+        "types": "types",
+    },
 )
 class SemanticTitleOptions:
     def __init__(
         self,
         *,
         require_scope: typing.Optional[builtins.bool] = None,
+        scopes: typing.Optional[typing.Sequence[builtins.str]] = None,
         types: typing.Optional[typing.Sequence[builtins.str]] = None,
     ) -> None:
         '''(experimental) Options for linting that PR titles follow Conventional Commits.
 
         :param require_scope: (experimental) Configure that a scope must always be provided. e.g. feat(ui), fix(core) Default: false
+        :param scopes: (experimental) Configure which scopes are allowed (newline-delimited). These are regex patterns auto-wrapped in ``^ $``. Default: - all scopes allowed
         :param types: (experimental) Configure a list of commit types that are allowed. Default: ["feat", "fix", "chore"]
 
         :see: https://www.conventionalcommits.org/
@@ -5060,10 +6616,13 @@ class SemanticTitleOptions:
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__9d043d0484269cca19493b2d2d5c51f9cfe65a12520148f80ef37f6855457de0)
             check_type(argname="argument require_scope", value=require_scope, expected_type=type_hints["require_scope"])
+            check_type(argname="argument scopes", value=scopes, expected_type=type_hints["scopes"])
             check_type(argname="argument types", value=types, expected_type=type_hints["types"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
         if require_scope is not None:
             self._values["require_scope"] = require_scope
+        if scopes is not None:
+            self._values["scopes"] = scopes
         if types is not None:
             self._values["types"] = types
 
@@ -5080,6 +6639,19 @@ class SemanticTitleOptions:
         result = self._values.get("require_scope")
         return typing.cast(typing.Optional[builtins.bool], result)
 
+    @builtins.property
+    def scopes(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) Configure which scopes are allowed (newline-delimited).
+
+        These are regex patterns auto-wrapped in ``^ $``.
+
+        :default: - all scopes allowed
+
+        :stability: experimental
+        '''
+        result = self._values.get("scopes")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
     @builtins.property
     def types(self) -> typing.Optional[typing.List[builtins.str]]:
         '''(experimental) Configure a list of commit types that are allowed.
@@ -5111,6 +6683,7 @@ class SemanticTitleOptions:
         "id": "id",
         "if_": "if",
         "name": "name",
+        "shell": "shell",
         "working_directory": "workingDirectory",
         "continue_on_error": "continueOnError",
         "timeout_minutes": "timeoutMinutes",
@@ -5125,6 +6698,7 @@ class SetupGitIdentityOptions(_JobStepConfiguration_9caff420):
         id: typing.Optional[builtins.str] = None,
         if_: typing.Optional[builtins.str] = None,
         name: typing.Optional[builtins.str] = None,
+        shell: typing.Optional[builtins.str] = None,
         working_directory: typing.Optional[builtins.str] = None,
         continue_on_error: typing.Optional[builtins.bool] = None,
         timeout_minutes: typing.Optional[jsii.Number] = None,
@@ -5135,6 +6709,7 @@ class SetupGitIdentityOptions(_JobStepConfiguration_9caff420):
         :param id: (experimental) A unique identifier for the step. You can use the id to reference the step in contexts.
         :param if_: (experimental) You can use the if conditional to prevent a job from running unless a condition is met. You can use any supported context and expression to create a conditional.
         :param name: (experimental) A name for your step to display on GitHub.
+        :param shell: (experimental) Overrides the default shell settings in the runner's operating system and the job's default. Refer to GitHub documentation for allowed values.
         :param working_directory: (experimental) Specifies a working directory for a step. Overrides a job's working directory.
         :param continue_on_error: (experimental) Prevents a job from failing when a step fails. Set to true to allow a job to pass when this step fails.
         :param timeout_minutes: (experimental) The maximum number of minutes to run the step before killing the process.
@@ -5150,6 +6725,7 @@ class SetupGitIdentityOptions(_JobStepConfiguration_9caff420):
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
             check_type(argname="argument if_", value=if_, expected_type=type_hints["if_"])
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument shell", value=shell, expected_type=type_hints["shell"])
             check_type(argname="argument working_directory", value=working_directory, expected_type=type_hints["working_directory"])
             check_type(argname="argument continue_on_error", value=continue_on_error, expected_type=type_hints["continue_on_error"])
             check_type(argname="argument timeout_minutes", value=timeout_minutes, expected_type=type_hints["timeout_minutes"])
@@ -5165,6 +6741,8 @@ class SetupGitIdentityOptions(_JobStepConfiguration_9caff420):
             self._values["if_"] = if_
         if name is not None:
             self._values["name"] = name
+        if shell is not None:
+            self._values["shell"] = shell
         if working_directory is not None:
             self._values["working_directory"] = working_directory
         if continue_on_error is not None:
@@ -5216,6 +6794,18 @@ class SetupGitIdentityOptions(_JobStepConfiguration_9caff420):
         result = self._values.get("name")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def shell(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Overrides the default shell settings in the runner's operating system and the job's default.
+
+        Refer to GitHub documentation for allowed values.
+
+        :see: https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsshell
+        :stability: experimental
+        '''
+        result = self._values.get("shell")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def working_directory(self) -> typing.Optional[builtins.str]:
         '''(experimental) Specifies a working directory for a step.
@@ -5617,6 +7207,7 @@ class TaskWorkflow(
         container: typing.Optional[typing.Union[_ContainerOptions_f50907af, typing.Dict[builtins.str, typing.Any]]] = None,
         download_lfs: typing.Optional[builtins.bool] = None,
         env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        environment: typing.Optional[builtins.str] = None,
         git_identity: typing.Optional[typing.Union[GitIdentity, typing.Dict[builtins.str, typing.Any]]] = None,
         job_defaults: typing.Optional[typing.Union[_JobDefaults_965f0d10, typing.Dict[builtins.str, typing.Any]]] = None,
         outputs: typing.Optional[typing.Mapping[builtins.str, typing.Union[_JobStepOutput_acebe827, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -5639,7 +7230,8 @@ class TaskWorkflow(
         :param container: Default: - default image
         :param download_lfs: (experimental) Whether to download files from Git LFS for this workflow. Default: - Use the setting on the corresponding GitHub project
         :param env: (experimental) Workflow environment variables. Default: {}
-        :param git_identity: (experimental) The git identity to use in this workflow.
+        :param environment: (experimental) The GitHub Actions environment used for the job. Default: - no environment used
+        :param git_identity: (experimental) The git identity to use in this workflow. Default: - default GitHub Actions user
         :param job_defaults: (experimental) Default settings for all steps in the TaskWorkflow Job.
         :param outputs: (experimental) Mapping of job output names to values/expressions. Default: {}
         :param post_build_steps: (experimental) Actions to run after the main build step. Default: - not set
@@ -5665,6 +7257,7 @@ class TaskWorkflow(
             container=container,
             download_lfs=download_lfs,
             env=env,
+            environment=environment,
             git_identity=git_identity,
             job_defaults=job_defaults,
             outputs=outputs,
@@ -5717,6 +7310,7 @@ class TaskWorkflowJob(
         container: typing.Optional[typing.Union[_ContainerOptions_f50907af, typing.Dict[builtins.str, typing.Any]]] = None,
         download_lfs: typing.Optional[builtins.bool] = None,
         env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        environment: typing.Optional[builtins.str] = None,
         git_identity: typing.Optional[typing.Union[GitIdentity, typing.Dict[builtins.str, typing.Any]]] = None,
         job_defaults: typing.Optional[typing.Union[_JobDefaults_965f0d10, typing.Dict[builtins.str, typing.Any]]] = None,
         outputs: typing.Optional[typing.Mapping[builtins.str, typing.Union[_JobStepOutput_acebe827, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -5736,7 +7330,8 @@ class TaskWorkflowJob(
         :param container: Default: - default image
         :param download_lfs: (experimental) Whether to download files from Git LFS for this workflow. Default: - Use the setting on the corresponding GitHub project
         :param env: (experimental) Workflow environment variables. Default: {}
-        :param git_identity: (experimental) The git identity to use in this workflow.
+        :param environment: (experimental) The GitHub Actions environment used for the job. Default: - no environment used
+        :param git_identity: (experimental) The git identity to use in this workflow. Default: - default GitHub Actions user
         :param job_defaults: (experimental) Default settings for all steps in the TaskWorkflow Job.
         :param outputs: (experimental) Mapping of job output names to values/expressions. Default: {}
         :param post_build_steps: (experimental) Actions to run after the main build step. Default: - not set
@@ -5759,6 +7354,7 @@ class TaskWorkflowJob(
             container=container,
             download_lfs=download_lfs,
             env=env,
+            environment=environment,
             git_identity=git_identity,
             job_defaults=job_defaults,
             outputs=outputs,
@@ -5829,11 +7425,11 @@ class TaskWorkflowJob(
 
     @builtins.property
     @jsii.member(jsii_name="environment")
-    def environment(self) -> typing.Any:
+    def environment(self) -> typing.Optional[builtins.str]:
         '''
         :stability: experimental
         '''
-        return typing.cast(typing.Any, jsii.get(self, "environment"))
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "environment"))
 
     @builtins.property
     @jsii.member(jsii_name="if")
@@ -5931,6 +7527,7 @@ class TaskWorkflowJob(
         "container": "container",
         "download_lfs": "downloadLfs",
         "env": "env",
+        "environment": "environment",
         "git_identity": "gitIdentity",
         "job_defaults": "jobDefaults",
         "outputs": "outputs",
@@ -5952,6 +7549,7 @@ class TaskWorkflowJobOptions:
         container: typing.Optional[typing.Union[_ContainerOptions_f50907af, typing.Dict[builtins.str, typing.Any]]] = None,
         download_lfs: typing.Optional[builtins.bool] = None,
         env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        environment: typing.Optional[builtins.str] = None,
         git_identity: typing.Optional[typing.Union[GitIdentity, typing.Dict[builtins.str, typing.Any]]] = None,
         job_defaults: typing.Optional[typing.Union[_JobDefaults_965f0d10, typing.Dict[builtins.str, typing.Any]]] = None,
         outputs: typing.Optional[typing.Mapping[builtins.str, typing.Union[_JobStepOutput_acebe827, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -5970,7 +7568,8 @@ class TaskWorkflowJobOptions:
         :param container: Default: - default image
         :param download_lfs: (experimental) Whether to download files from Git LFS for this workflow. Default: - Use the setting on the corresponding GitHub project
         :param env: (experimental) Workflow environment variables. Default: {}
-        :param git_identity: (experimental) The git identity to use in this workflow.
+        :param environment: (experimental) The GitHub Actions environment used for the job. Default: - no environment used
+        :param git_identity: (experimental) The git identity to use in this workflow. Default: - default GitHub Actions user
         :param job_defaults: (experimental) Default settings for all steps in the TaskWorkflow Job.
         :param outputs: (experimental) Mapping of job output names to values/expressions. Default: {}
         :param post_build_steps: (experimental) Actions to run after the main build step. Default: - not set
@@ -6002,6 +7601,7 @@ class TaskWorkflowJobOptions:
             check_type(argname="argument container", value=container, expected_type=type_hints["container"])
             check_type(argname="argument download_lfs", value=download_lfs, expected_type=type_hints["download_lfs"])
             check_type(argname="argument env", value=env, expected_type=type_hints["env"])
+            check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
             check_type(argname="argument git_identity", value=git_identity, expected_type=type_hints["git_identity"])
             check_type(argname="argument job_defaults", value=job_defaults, expected_type=type_hints["job_defaults"])
             check_type(argname="argument outputs", value=outputs, expected_type=type_hints["outputs"])
@@ -6025,6 +7625,8 @@ class TaskWorkflowJobOptions:
             self._values["download_lfs"] = download_lfs
         if env is not None:
             self._values["env"] = env
+        if environment is not None:
+            self._values["environment"] = environment
         if git_identity is not None:
             self._values["git_identity"] = git_identity
         if job_defaults is not None:
@@ -6115,10 +7717,23 @@ class TaskWorkflowJobOptions:
         result = self._values.get("env")
         return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
 
+    @builtins.property
+    def environment(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The GitHub Actions environment used for the job.
+
+        :default: - no environment used
+
+        :stability: experimental
+        '''
+        result = self._values.get("environment")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def git_identity(self) -> typing.Optional[GitIdentity]:
         '''(experimental) The git identity to use in this workflow.
 
+        :default: - default GitHub Actions user
+
         :stability: experimental
         '''
         result = self._values.get("git_identity")
@@ -6226,6 +7841,7 @@ class TaskWorkflowJobOptions:
         "container": "container",
         "download_lfs": "downloadLfs",
         "env": "env",
+        "environment": "environment",
         "git_identity": "gitIdentity",
         "job_defaults": "jobDefaults",
         "outputs": "outputs",
@@ -6251,6 +7867,7 @@ class TaskWorkflowOptions(TaskWorkflowJobOptions):
         container: typing.Optional[typing.Union[_ContainerOptions_f50907af, typing.Dict[builtins.str, typing.Any]]] = None,
         download_lfs: typing.Optional[builtins.bool] = None,
         env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        environment: typing.Optional[builtins.str] = None,
         git_identity: typing.Optional[typing.Union[GitIdentity, typing.Dict[builtins.str, typing.Any]]] = None,
         job_defaults: typing.Optional[typing.Union[_JobDefaults_965f0d10, typing.Dict[builtins.str, typing.Any]]] = None,
         outputs: typing.Optional[typing.Mapping[builtins.str, typing.Union[_JobStepOutput_acebe827, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -6273,7 +7890,8 @@ class TaskWorkflowOptions(TaskWorkflowJobOptions):
         :param container: Default: - default image
         :param download_lfs: (experimental) Whether to download files from Git LFS for this workflow. Default: - Use the setting on the corresponding GitHub project
         :param env: (experimental) Workflow environment variables. Default: {}
-        :param git_identity: (experimental) The git identity to use in this workflow.
+        :param environment: (experimental) The GitHub Actions environment used for the job. Default: - no environment used
+        :param git_identity: (experimental) The git identity to use in this workflow. Default: - default GitHub Actions user
         :param job_defaults: (experimental) Default settings for all steps in the TaskWorkflow Job.
         :param outputs: (experimental) Mapping of job output names to values/expressions. Default: {}
         :param post_build_steps: (experimental) Actions to run after the main build step. Default: - not set
@@ -6311,6 +7929,7 @@ class TaskWorkflowOptions(TaskWorkflowJobOptions):
             check_type(argname="argument container", value=container, expected_type=type_hints["container"])
             check_type(argname="argument download_lfs", value=download_lfs, expected_type=type_hints["download_lfs"])
             check_type(argname="argument env", value=env, expected_type=type_hints["env"])
+            check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
             check_type(argname="argument git_identity", value=git_identity, expected_type=type_hints["git_identity"])
             check_type(argname="argument job_defaults", value=job_defaults, expected_type=type_hints["job_defaults"])
             check_type(argname="argument outputs", value=outputs, expected_type=type_hints["outputs"])
@@ -6340,6 +7959,8 @@ class TaskWorkflowOptions(TaskWorkflowJobOptions):
             self._values["download_lfs"] = download_lfs
         if env is not None:
             self._values["env"] = env
+        if environment is not None:
+            self._values["environment"] = environment
         if git_identity is not None:
             self._values["git_identity"] = git_identity
         if job_defaults is not None:
@@ -6434,10 +8055,23 @@ class TaskWorkflowOptions(TaskWorkflowJobOptions):
         result = self._values.get("env")
         return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
 
+    @builtins.property
+    def environment(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The GitHub Actions environment used for the job.
+
+        :default: - no environment used
+
+        :stability: experimental
+        '''
+        result = self._values.get("environment")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def git_identity(self) -> typing.Optional[GitIdentity]:
         '''(experimental) The git identity to use in this workflow.
 
+        :default: - default GitHub Actions user
+
         :stability: experimental
         '''
         result = self._values.get("git_identity")
@@ -6584,6 +8218,7 @@ class TaskWorkflowOptions(TaskWorkflowJobOptions):
         "id": "id",
         "if_": "if",
         "name": "name",
+        "shell": "shell",
         "working_directory": "workingDirectory",
         "continue_on_error": "continueOnError",
         "timeout_minutes": "timeoutMinutes",
@@ -6598,6 +8233,7 @@ class UploadArtifactOptions(_JobStepConfiguration_9caff420):
         id: typing.Optional[builtins.str] = None,
         if_: typing.Optional[builtins.str] = None,
         name: typing.Optional[builtins.str] = None,
+        shell: typing.Optional[builtins.str] = None,
         working_directory: typing.Optional[builtins.str] = None,
         continue_on_error: typing.Optional[builtins.bool] = None,
         timeout_minutes: typing.Optional[jsii.Number] = None,
@@ -6608,6 +8244,7 @@ class UploadArtifactOptions(_JobStepConfiguration_9caff420):
         :param id: (experimental) A unique identifier for the step. You can use the id to reference the step in contexts.
         :param if_: (experimental) You can use the if conditional to prevent a job from running unless a condition is met. You can use any supported context and expression to create a conditional.
         :param name: (experimental) A name for your step to display on GitHub.
+        :param shell: (experimental) Overrides the default shell settings in the runner's operating system and the job's default. Refer to GitHub documentation for allowed values.
         :param working_directory: (experimental) Specifies a working directory for a step. Overrides a job's working directory.
         :param continue_on_error: (experimental) Prevents a job from failing when a step fails. Set to true to allow a job to pass when this step fails.
         :param timeout_minutes: (experimental) The maximum number of minutes to run the step before killing the process.
@@ -6623,6 +8260,7 @@ class UploadArtifactOptions(_JobStepConfiguration_9caff420):
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
             check_type(argname="argument if_", value=if_, expected_type=type_hints["if_"])
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument shell", value=shell, expected_type=type_hints["shell"])
             check_type(argname="argument working_directory", value=working_directory, expected_type=type_hints["working_directory"])
             check_type(argname="argument continue_on_error", value=continue_on_error, expected_type=type_hints["continue_on_error"])
             check_type(argname="argument timeout_minutes", value=timeout_minutes, expected_type=type_hints["timeout_minutes"])
@@ -6638,6 +8276,8 @@ class UploadArtifactOptions(_JobStepConfiguration_9caff420):
             self._values["if_"] = if_
         if name is not None:
             self._values["name"] = name
+        if shell is not None:
+            self._values["shell"] = shell
         if working_directory is not None:
             self._values["working_directory"] = working_directory
         if continue_on_error is not None:
@@ -6689,6 +8329,18 @@ class UploadArtifactOptions(_JobStepConfiguration_9caff420):
         result = self._values.get("name")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def shell(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Overrides the default shell settings in the runner's operating system and the job's default.
+
+        Refer to GitHub documentation for allowed values.
+
+        :see: https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsshell
+        :stability: experimental
+        '''
+        result = self._values.get("shell")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def working_directory(self) -> typing.Optional[builtins.str]:
         '''(experimental) Specifies a working directory for a step.
@@ -6750,7 +8402,9 @@ class UploadArtifactOptions(_JobStepConfiguration_9caff420):
         "path": "path",
         "compression_level": "compressionLevel",
         "if_no_files_found": "ifNoFilesFound",
+        "include_hidden_files": "includeHiddenFiles",
         "name": "name",
+        "overwrite": "overwrite",
         "retention_days": "retentionDays",
     },
 )
@@ -6761,14 +8415,18 @@ class UploadArtifactWith:
         path: builtins.str,
         compression_level: typing.Optional[jsii.Number] = None,
         if_no_files_found: typing.Optional[builtins.str] = None,
+        include_hidden_files: typing.Optional[builtins.bool] = None,
         name: typing.Optional[builtins.str] = None,
+        overwrite: typing.Optional[builtins.bool] = None,
         retention_days: typing.Optional[jsii.Number] = None,
     ) -> None:
         '''
         :param path: (experimental) A file, directory or wildcard pattern that describes what to upload.
         :param compression_level: (experimental) The level of compression for Zlib to be applied to the artifact archive. The value can range from 0 to 9. For large files that are not easily compressed, a value of 0 is recommended for significantly faster uploads. Default: 6
         :param if_no_files_found: (experimental) The desired behavior if no files are found using the provided path. Available Options: warn: Output a warning but do not fail the action error: Fail the action with an error message ignore: Do not output any warnings or errors, the action does not fail Default: "warn"
+        :param include_hidden_files: (experimental) Whether to include hidden files in the provided path in the artifact. The file contents of any hidden files in the path should be validated before enabled this to avoid uploading sensitive information. Default: false
         :param name: (experimental) Name of the artifact to upload. Default: "artifact"
+        :param overwrite: (experimental) Whether action should overwrite an existing artifact with the same name (should one exist). Introduced in v4 and represents a breaking change from the behavior of the v3 action. To maintain backwards compatibility with existing, this should be set the ``true`` (the default). Default: true
         :param retention_days: (experimental) Duration after which artifact will expire in days. 0 means using default repository retention. Minimum 1 day. Maximum 90 days unless changed from the repository settings page. Default: - The default repository retention
 
         :stability: experimental
@@ -6778,7 +8436,9 @@ class UploadArtifactWith:
             check_type(argname="argument path", value=path, expected_type=type_hints["path"])
             check_type(argname="argument compression_level", value=compression_level, expected_type=type_hints["compression_level"])
             check_type(argname="argument if_no_files_found", value=if_no_files_found, expected_type=type_hints["if_no_files_found"])
+            check_type(argname="argument include_hidden_files", value=include_hidden_files, expected_type=type_hints["include_hidden_files"])
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument overwrite", value=overwrite, expected_type=type_hints["overwrite"])
             check_type(argname="argument retention_days", value=retention_days, expected_type=type_hints["retention_days"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "path": path,
@@ -6787,8 +8447,12 @@ class UploadArtifactWith:
             self._values["compression_level"] = compression_level
         if if_no_files_found is not None:
             self._values["if_no_files_found"] = if_no_files_found
+        if include_hidden_files is not None:
+            self._values["include_hidden_files"] = include_hidden_files
         if name is not None:
             self._values["name"] = name
+        if overwrite is not None:
+            self._values["overwrite"] = overwrite
         if retention_days is not None:
             self._values["retention_days"] = retention_days
 
@@ -6832,6 +8496,19 @@ class UploadArtifactWith:
         result = self._values.get("if_no_files_found")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def include_hidden_files(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Whether to include hidden files in the provided path in the artifact.
+
+        The file contents of any hidden files in the path should be validated before enabled this to avoid uploading sensitive information.
+
+        :default: false
+
+        :stability: experimental
+        '''
+        result = self._values.get("include_hidden_files")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     @builtins.property
     def name(self) -> typing.Optional[builtins.str]:
         '''(experimental) Name of the artifact to upload.
@@ -6843,6 +8520,20 @@ class UploadArtifactWith:
         result = self._values.get("name")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def overwrite(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Whether action should overwrite an existing artifact with the same name (should one exist).
+
+        Introduced in v4 and represents a breaking change from the behavior of the v3 action.
+        To maintain backwards compatibility with existing, this should be set the ``true`` (the default).
+
+        :default: true
+
+        :stability: experimental
+        '''
+        result = self._values.get("overwrite")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     @builtins.property
     def retention_days(self) -> typing.Optional[jsii.Number]:
         '''(experimental) Duration after which artifact will expire in days. 0 means using default repository retention.
@@ -7047,6 +8738,7 @@ class WorkflowActions(
         patch_file: typing.Optional[builtins.str] = None,
         fetch_depth: typing.Optional[jsii.Number] = None,
         lfs: typing.Optional[builtins.bool] = None,
+        path: typing.Optional[builtins.str] = None,
         ref: typing.Optional[builtins.str] = None,
         repository: typing.Optional[builtins.str] = None,
         token: typing.Optional[builtins.str] = None,
@@ -7056,6 +8748,7 @@ class WorkflowActions(
         :param patch_file: (experimental) The name of the artifact the patch is stored as. Default: ".repo.patch"
         :param fetch_depth: (experimental) Number of commits to fetch. 0 indicates all history for all branches and tags. Default: 1
         :param lfs: (experimental) Whether LFS is enabled for the GitHub repository. Default: false
+        :param path: (experimental) Relative path under $GITHUB_WORKSPACE to place the repository. Default: - $GITHUB_WORKSPACE
         :param ref: (experimental) Branch or tag name. Default: - the default branch is implicitly used
         :param repository: (experimental) The repository (owner/repo) to use. Default: - the default repository is implicitly used
         :param token: (experimental) A GitHub token to use when checking out the repository. If the intent is to push changes back to the branch, then you must use a PAT with ``repo`` (and possibly ``workflows``) permissions. Default: - the default GITHUB_TOKEN is implicitly used
@@ -7068,6 +8761,7 @@ class WorkflowActions(
             patch_file=patch_file,
             fetch_depth=fetch_depth,
             lfs=lfs,
+            path=path,
             ref=ref,
             repository=repository,
             token=token,
@@ -7102,7 +8796,7 @@ class WorkflowActions(
         :param base_branch: (experimental) Sets the pull request base branch. Default: - The branch checked out in the workflow.
         :param branch_name: (experimental) The pull request branch name. Default: ``github-actions/${options.workflowName}``
         :param credentials: (experimental) The job credentials used to create the pull request. Provided credentials must have permissions to create a pull request on the repository.
-        :param git_identity: (experimental) The git identity used to create the commit. Default: - the default github-actions user
+        :param git_identity: (experimental) The git identity used to create the commit. Default: - default GitHub Actions user
         :param labels: (experimental) Labels to apply on the PR. Default: - no labels.
         :param signoff: (experimental) Add Signed-off-by line by the committer at the end of the commit log message. Default: true
         :param step_id: (experimental) The step ID which produces the output which indicates if a patch was created. Default: "create_pr"
@@ -7235,7 +8929,7 @@ class WorkflowJobs(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowJob
         :param base_branch: (experimental) Sets the pull request base branch. Default: - The branch checked out in the workflow.
         :param branch_name: (experimental) The pull request branch name. Default: ``github-actions/${options.workflowName}``
         :param credentials: (experimental) The job credentials used to create the pull request. Provided credentials must have permissions to create a pull request on the repository.
-        :param git_identity: (experimental) The git identity used to create the commit. Default: - the default github-actions user
+        :param git_identity: (experimental) The git identity used to create the commit. Default: - default GitHub Actions user
         :param labels: (experimental) Labels to apply on the PR. Default: - no labels.
         :param signoff: (experimental) Add Signed-off-by line by the committer at the end of the commit log message. Default: true
         :param step_id: (experimental) The step ID which produces the output which indicates if a patch was created. Default: "create_pr"
@@ -7291,6 +8985,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
         id: typing.Optional[builtins.str] = None,
         if_: typing.Optional[builtins.str] = None,
         name: typing.Optional[builtins.str] = None,
+        shell: typing.Optional[builtins.str] = None,
         working_directory: typing.Optional[builtins.str] = None,
     ) -> _JobStep_c3287c05:
         '''(experimental) Checks out a repository.
@@ -7302,6 +8997,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
         :param id: (experimental) A unique identifier for the step. You can use the id to reference the step in contexts.
         :param if_: (experimental) You can use the if conditional to prevent a job from running unless a condition is met. You can use any supported context and expression to create a conditional.
         :param name: (experimental) A name for your step to display on GitHub.
+        :param shell: (experimental) Overrides the default shell settings in the runner's operating system and the job's default. Refer to GitHub documentation for allowed values.
         :param working_directory: (experimental) Specifies a working directory for a step. Overrides a job's working directory.
 
         :return: A JobStep that checks out a repository
@@ -7316,11 +9012,57 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
             id=id,
             if_=if_,
             name=name,
+            shell=shell,
             working_directory=working_directory,
         )
 
         return typing.cast(_JobStep_c3287c05, jsii.sinvoke(cls, "checkout", [options]))
 
+    @jsii.member(jsii_name="downloadArtifact")
+    @builtins.classmethod
+    def download_artifact(
+        cls,
+        *,
+        with_: typing.Union[DownloadArtifactWith, typing.Dict[builtins.str, typing.Any]],
+        continue_on_error: typing.Optional[builtins.bool] = None,
+        timeout_minutes: typing.Optional[jsii.Number] = None,
+        env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        id: typing.Optional[builtins.str] = None,
+        if_: typing.Optional[builtins.str] = None,
+        name: typing.Optional[builtins.str] = None,
+        shell: typing.Optional[builtins.str] = None,
+        working_directory: typing.Optional[builtins.str] = None,
+    ) -> _JobStep_c3287c05:
+        '''(experimental) Downloads an artifact.
+
+        :param with_: (experimental) Options for ``download-artifact``.
+        :param continue_on_error: (experimental) Prevents a job from failing when a step fails. Set to true to allow a job to pass when this step fails.
+        :param timeout_minutes: (experimental) The maximum number of minutes to run the step before killing the process.
+        :param env: (experimental) Sets environment variables for steps to use in the runner environment. You can also set environment variables for the entire workflow or a job.
+        :param id: (experimental) A unique identifier for the step. You can use the id to reference the step in contexts.
+        :param if_: (experimental) You can use the if conditional to prevent a job from running unless a condition is met. You can use any supported context and expression to create a conditional.
+        :param name: (experimental) A name for your step to display on GitHub.
+        :param shell: (experimental) Overrides the default shell settings in the runner's operating system and the job's default. Refer to GitHub documentation for allowed values.
+        :param working_directory: (experimental) Specifies a working directory for a step. Overrides a job's working directory.
+
+        :return: A JobStep that downloads an artifact
+
+        :stability: experimental
+        '''
+        options = DownloadArtifactOptions(
+            with_=with_,
+            continue_on_error=continue_on_error,
+            timeout_minutes=timeout_minutes,
+            env=env,
+            id=id,
+            if_=if_,
+            name=name,
+            shell=shell,
+            working_directory=working_directory,
+        )
+
+        return typing.cast(_JobStep_c3287c05, jsii.sinvoke(cls, "downloadArtifact", [options]))
+
     @jsii.member(jsii_name="setupGitIdentity")
     @builtins.classmethod
     def setup_git_identity(
@@ -7333,6 +9075,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
         id: typing.Optional[builtins.str] = None,
         if_: typing.Optional[builtins.str] = None,
         name: typing.Optional[builtins.str] = None,
+        shell: typing.Optional[builtins.str] = None,
         working_directory: typing.Optional[builtins.str] = None,
     ) -> _JobStep_c3287c05:
         '''(experimental) Configures the git identity (user name and email).
@@ -7344,6 +9087,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
         :param id: (experimental) A unique identifier for the step. You can use the id to reference the step in contexts.
         :param if_: (experimental) You can use the if conditional to prevent a job from running unless a condition is met. You can use any supported context and expression to create a conditional.
         :param name: (experimental) A name for your step to display on GitHub.
+        :param shell: (experimental) Overrides the default shell settings in the runner's operating system and the job's default. Refer to GitHub documentation for allowed values.
         :param working_directory: (experimental) Specifies a working directory for a step. Overrides a job's working directory.
 
         :return: Job step that configures the provided git identity
@@ -7358,6 +9102,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
             id=id,
             if_=if_,
             name=name,
+            shell=shell,
             working_directory=working_directory,
         )
 
@@ -7375,6 +9120,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
         id: typing.Optional[builtins.str] = None,
         if_: typing.Optional[builtins.str] = None,
         name: typing.Optional[builtins.str] = None,
+        shell: typing.Optional[builtins.str] = None,
         working_directory: typing.Optional[builtins.str] = None,
     ) -> _JobStep_c3287c05:
         '''(experimental) Checks if a tag exists.
@@ -7392,6 +9138,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
         :param id: (experimental) A unique identifier for the step. You can use the id to reference the step in contexts.
         :param if_: (experimental) You can use the if conditional to prevent a job from running unless a condition is met. You can use any supported context and expression to create a conditional.
         :param name: (experimental) A name for your step to display on GitHub.
+        :param shell: (experimental) Overrides the default shell settings in the runner's operating system and the job's default. Refer to GitHub documentation for allowed values.
         :param working_directory: (experimental) Specifies a working directory for a step. Overrides a job's working directory.
 
         :return: Job step that checks if the provided tag exists
@@ -7408,6 +9155,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
             id=id,
             if_=if_,
             name=name,
+            shell=shell,
             working_directory=working_directory,
         )
 
@@ -7425,6 +9173,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
         id: typing.Optional[builtins.str] = None,
         if_: typing.Optional[builtins.str] = None,
         name: typing.Optional[builtins.str] = None,
+        shell: typing.Optional[builtins.str] = None,
         working_directory: typing.Optional[builtins.str] = None,
     ) -> _JobStep_c3287c05:
         '''(experimental) Uploads an artifact.
@@ -7436,6 +9185,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
         :param id: (experimental) A unique identifier for the step. You can use the id to reference the step in contexts.
         :param if_: (experimental) You can use the if conditional to prevent a job from running unless a condition is met. You can use any supported context and expression to create a conditional.
         :param name: (experimental) A name for your step to display on GitHub.
+        :param shell: (experimental) Overrides the default shell settings in the runner's operating system and the job's default. Refer to GitHub documentation for allowed values.
         :param working_directory: (experimental) Specifies a working directory for a step. Overrides a job's working directory.
 
         :return: A JobStep that uploads an artifact
@@ -7450,6 +9200,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
             id=id,
             if_=if_,
             name=name,
+            shell=shell,
             working_directory=working_directory,
         )
 
@@ -7461,19 +9212,27 @@ __all__ = [
     "AutoApproveOptions",
     "AutoMerge",
     "AutoMergeOptions",
+    "AutoQueue",
+    "AutoQueueOptions",
     "CheckoutOptions",
     "CheckoutWith",
     "CheckoutWithPatchOptions",
+    "ConcurrencyOptions",
     "ContributorStatementOptions",
     "CreatePullRequestOptions",
     "Dependabot",
     "DependabotAllow",
     "DependabotGroup",
+    "DependabotGroupAppliesTo",
+    "DependabotGroupDependencyType",
+    "DependabotGroupUpdateType",
     "DependabotIgnore",
     "DependabotOptions",
     "DependabotRegistry",
     "DependabotRegistryType",
     "DependabotScheduleInterval",
+    "DownloadArtifactOptions",
+    "DownloadArtifactWith",
     "GitHub",
     "GitHubActionsProvider",
     "GitHubOptions",
@@ -7486,11 +9245,16 @@ __all__ = [
     "GithubWorkflow",
     "GithubWorkflowOptions",
     "IAddConditionsLater",
+    "MergeMethod",
+    "MergeQueue",
+    "MergeQueueOptions",
     "Mergify",
     "MergifyConditionalOperator",
     "MergifyOptions",
     "MergifyQueue",
     "MergifyRule",
+    "PullRequestBackport",
+    "PullRequestBackportOptions",
     "PullRequestFromPatchOptions",
     "PullRequestLint",
     "PullRequestLintOptions",
@@ -7577,12 +9341,38 @@ def _typecheckingstub__a8ab02e50aae05e5a55d4a4adc4369d19ed7205ed83b7ca13d32b3d62
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__d1a61bf6b1de263219ae71fb7c610ca1482abce41103e188b62ebe38e0314b58(
+    scope: _constructs_77d1e7e8.IConstruct,
+    *,
+    allowed_usernames: typing.Optional[typing.Sequence[builtins.str]] = None,
+    labels: typing.Optional[typing.Sequence[builtins.str]] = None,
+    merge_method: typing.Optional[MergeMethod] = None,
+    projen_credentials: typing.Optional[GithubCredentials] = None,
+    runs_on: typing.Optional[typing.Sequence[builtins.str]] = None,
+    target_branches: typing.Optional[typing.Sequence[builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__f138097d225158d553505a4839bf1c114c4a0e41bc55b7d24234176015382a5d(
+    *,
+    allowed_usernames: typing.Optional[typing.Sequence[builtins.str]] = None,
+    labels: typing.Optional[typing.Sequence[builtins.str]] = None,
+    merge_method: typing.Optional[MergeMethod] = None,
+    projen_credentials: typing.Optional[GithubCredentials] = None,
+    runs_on: typing.Optional[typing.Sequence[builtins.str]] = None,
+    target_branches: typing.Optional[typing.Sequence[builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__a17b4445d77135e079ad1d957d41f1a5ade398e6b6ba84b471b26b6adab221ac(
     *,
     env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     id: typing.Optional[builtins.str] = None,
     if_: typing.Optional[builtins.str] = None,
     name: typing.Optional[builtins.str] = None,
+    shell: typing.Optional[builtins.str] = None,
     working_directory: typing.Optional[builtins.str] = None,
     continue_on_error: typing.Optional[builtins.bool] = None,
     timeout_minutes: typing.Optional[jsii.Number] = None,
@@ -7595,6 +9385,7 @@ def _typecheckingstub__57379070911f0df36ef38a23c138780de73f270c4e64ea8e6b7f4f128
     *,
     fetch_depth: typing.Optional[jsii.Number] = None,
     lfs: typing.Optional[builtins.bool] = None,
+    path: typing.Optional[builtins.str] = None,
     ref: typing.Optional[builtins.str] = None,
     repository: typing.Optional[builtins.str] = None,
     token: typing.Optional[builtins.str] = None,
@@ -7606,6 +9397,7 @@ def _typecheckingstub__c7405ea05e49b1f743e00dc103618fbd659c979bbec234492b8928ed6
     *,
     fetch_depth: typing.Optional[jsii.Number] = None,
     lfs: typing.Optional[builtins.bool] = None,
+    path: typing.Optional[builtins.str] = None,
     ref: typing.Optional[builtins.str] = None,
     repository: typing.Optional[builtins.str] = None,
     token: typing.Optional[builtins.str] = None,
@@ -7614,6 +9406,14 @@ def _typecheckingstub__c7405ea05e49b1f743e00dc103618fbd659c979bbec234492b8928ed6
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__c4114f6f3330f94beb00dba1183281a663b31179a714c1f1412277b784153015(
+    *,
+    cancel_in_progress: typing.Optional[builtins.bool] = None,
+    group: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__4bf4a36aad325b457168493fe21f1efbc534c83e8685d03341390fcbf3d1c0bc(
     *,
     exempt_labels: typing.Optional[typing.Sequence[builtins.str]] = None,
@@ -7653,6 +9453,7 @@ def _typecheckingstub__2caae883697ce14c090e89c8fd0dbbab7e7c0f31d6d4d66311f05a679
     registries: typing.Optional[typing.Mapping[builtins.str, typing.Union[DependabotRegistry, typing.Dict[builtins.str, typing.Any]]]] = None,
     reviewers: typing.Optional[typing.Sequence[builtins.str]] = None,
     schedule_interval: typing.Optional[DependabotScheduleInterval] = None,
+    target_branch: typing.Optional[builtins.str] = None,
     versioning_strategy: typing.Optional[VersioningStrategy] = None,
 ) -> None:
     """Type checking stubs"""
@@ -7681,7 +9482,10 @@ def _typecheckingstub__95f7e72bd3f0d0b83df633a27522aaab6cab1baeaf4b90de44beff992
 def _typecheckingstub__97650f1e1a170d34a5bd50211445090d04d890ec494749c1eb3f5a1fabbec7d4(
     *,
     patterns: typing.Sequence[builtins.str],
+    applies_to: typing.Optional[DependabotGroupAppliesTo] = None,
+    dependency_type: typing.Optional[DependabotGroupDependencyType] = None,
     exclude_patterns: typing.Optional[typing.Sequence[builtins.str]] = None,
+    update_types: typing.Optional[typing.Sequence[DependabotGroupUpdateType]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -7706,6 +9510,7 @@ def _typecheckingstub__d0078e67a79ce21c460b876a72b4fbd4a358306502062bdf9bdb13085
     registries: typing.Optional[typing.Mapping[builtins.str, typing.Union[DependabotRegistry, typing.Dict[builtins.str, typing.Any]]]] = None,
     reviewers: typing.Optional[typing.Sequence[builtins.str]] = None,
     schedule_interval: typing.Optional[DependabotScheduleInterval] = None,
+    target_branch: typing.Optional[builtins.str] = None,
     versioning_strategy: typing.Optional[VersioningStrategy] = None,
 ) -> None:
     """Type checking stubs"""
@@ -7725,14 +9530,46 @@ def _typecheckingstub__71dcef0810bce091e26ea45c125fc125b6b541331dd4f1fa62466d1f5
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__c7f153d5c1001fcb119385a05448ea85e212f46cc420d578734261b8353a641b(
+    *,
+    env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    id: typing.Optional[builtins.str] = None,
+    if_: typing.Optional[builtins.str] = None,
+    name: typing.Optional[builtins.str] = None,
+    shell: typing.Optional[builtins.str] = None,
+    working_directory: typing.Optional[builtins.str] = None,
+    continue_on_error: typing.Optional[builtins.bool] = None,
+    timeout_minutes: typing.Optional[jsii.Number] = None,
+    with_: typing.Union[DownloadArtifactWith, typing.Dict[builtins.str, typing.Any]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__3e5008f68a85d8490ecf62a54f413b82cc795d9a14d3bc8eabcc2720f31de50c(
+    *,
+    merge_multiple: typing.Optional[builtins.bool] = None,
+    name: typing.Optional[builtins.str] = None,
+    path: typing.Optional[builtins.str] = None,
+    pattern: typing.Optional[builtins.str] = None,
+    repository: typing.Optional[builtins.str] = None,
+    run_id: typing.Optional[builtins.str] = None,
+    token: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__65db11e8703472c7fa4e013294c649e43b7f8634b29ca11be71b46d8c549c4d1(
     project: _Project_57d89203,
     *,
     download_lfs: typing.Optional[builtins.bool] = None,
+    merge_queue: typing.Optional[builtins.bool] = None,
+    merge_queue_options: typing.Optional[typing.Union[MergeQueueOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     mergify: typing.Optional[builtins.bool] = None,
     mergify_options: typing.Optional[typing.Union[MergifyOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     projen_credentials: typing.Optional[GithubCredentials] = None,
     projen_token_secret: typing.Optional[builtins.str] = None,
+    pull_request_backport: typing.Optional[builtins.bool] = None,
+    pull_request_backport_options: typing.Optional[typing.Union[PullRequestBackportOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     pull_request_lint: typing.Optional[builtins.bool] = None,
     pull_request_lint_options: typing.Optional[typing.Union[PullRequestLintOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     workflows: typing.Optional[builtins.bool] = None,
@@ -7780,10 +9617,14 @@ def _typecheckingstub__20166ac47381861e1a45b550a5e9646380c52a927fca9ebf00ec36dab
 def _typecheckingstub__c22e66f011c96f13a6f4e5b07bb676bf98b477678e968ee61f79ee107a7d2bd7(
     *,
     download_lfs: typing.Optional[builtins.bool] = None,
+    merge_queue: typing.Optional[builtins.bool] = None,
+    merge_queue_options: typing.Optional[typing.Union[MergeQueueOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     mergify: typing.Optional[builtins.bool] = None,
     mergify_options: typing.Optional[typing.Union[MergifyOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     projen_credentials: typing.Optional[GithubCredentials] = None,
     projen_token_secret: typing.Optional[builtins.str] = None,
+    pull_request_backport: typing.Optional[builtins.bool] = None,
+    pull_request_backport_options: typing.Optional[typing.Union[PullRequestBackportOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     pull_request_lint: typing.Optional[builtins.bool] = None,
     pull_request_lint_options: typing.Optional[typing.Union[PullRequestLintOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     workflows: typing.Optional[builtins.bool] = None,
@@ -7843,8 +9684,10 @@ def _typecheckingstub__f9975d58a3cca9992aa51d0da1572c207d374c146dec0474fc911a567
 def _typecheckingstub__cfe552d6288d1f706792afe5f041e666db050b8d0d3bb7062899a3bdefe652a8(
     *,
     app_id_secret: typing.Optional[builtins.str] = None,
+    owner: typing.Optional[builtins.str] = None,
     permissions: typing.Optional[typing.Union[_AppPermissions_59709d51, typing.Dict[builtins.str, typing.Any]]] = None,
     private_key_secret: typing.Optional[builtins.str] = None,
+    repositories: typing.Optional[typing.Sequence[builtins.str]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -7860,8 +9703,11 @@ def _typecheckingstub__ca4f375b4fda039fc4fb5b2f4ad26a9d1695085d170d2d76e6d720c7c
     github: GitHub,
     name: builtins.str,
     *,
-    concurrency: typing.Optional[builtins.str] = None,
+    concurrency_options: typing.Optional[typing.Union[ConcurrencyOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+    env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    file_name: typing.Optional[builtins.str] = None,
     force: typing.Optional[builtins.bool] = None,
+    limit_concurrency: typing.Optional[builtins.bool] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -7912,8 +9758,30 @@ def _typecheckingstub__a6273080200c7722c9774364ee8460bccd3337cd48edc420530ca75f7
 
 def _typecheckingstub__c779b00d3df0cff3a9570cc6ed35339952399a898d5854423c3329b55bf736ec(
     *,
-    concurrency: typing.Optional[builtins.str] = None,
+    concurrency_options: typing.Optional[typing.Union[ConcurrencyOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+    env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    file_name: typing.Optional[builtins.str] = None,
     force: typing.Optional[builtins.bool] = None,
+    limit_concurrency: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__8d0860f4805d4f3404f9b940157e555ab934aaea8c3deecc2681f63f23129dc7(
+    scope: _constructs_77d1e7e8.IConstruct,
+    *,
+    auto_queue: typing.Optional[builtins.bool] = None,
+    auto_queue_options: typing.Optional[typing.Union[AutoQueueOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+    target_branches: typing.Optional[typing.Sequence[builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__5ed41b74ffbee4fd52a12674b58bd68e113a707d7c3dec6e1ecb7f9647debbc3(
+    *,
+    auto_queue: typing.Optional[builtins.bool] = None,
+    auto_queue_options: typing.Optional[typing.Union[AutoQueueOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+    target_branches: typing.Optional[typing.Sequence[builtins.str]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -7945,9 +9813,12 @@ def _typecheckingstub__527734fcd5357c536553ff5f47fe5062b93958305a451f587c870879e
 
 def _typecheckingstub__0471efd0a49bc64e556512e765a1df23d4a975f26cb6de765579b4173907f467(
     *,
-    conditions: typing.Sequence[typing.Union[builtins.str, typing.Union[MergifyConditionalOperator, typing.Dict[builtins.str, typing.Any]]]],
+    commit_message_template: builtins.str,
     name: builtins.str,
+    conditions: typing.Optional[typing.Sequence[typing.Union[builtins.str, typing.Union[MergifyConditionalOperator, typing.Dict[builtins.str, typing.Any]]]]] = None,
+    merge_conditions: typing.Optional[typing.Sequence[typing.Union[builtins.str, typing.Union[MergifyConditionalOperator, typing.Dict[builtins.str, typing.Any]]]]] = None,
     merge_method: typing.Optional[builtins.str] = None,
+    queue_conditions: typing.Optional[typing.Sequence[typing.Union[builtins.str, typing.Union[MergifyConditionalOperator, typing.Dict[builtins.str, typing.Any]]]]] = None,
     update_method: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
@@ -7962,6 +9833,33 @@ def _typecheckingstub__95405391335691b357d88cc73d37d1ee20fceae6cf671811812f63972
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__a321227b5ffc19f1220367db19ad9a6c84aec3e2bf74ba19db5a89f3ee8c9ce4(
+    scope: _constructs_77d1e7e8.IConstruct,
+    *,
+    auto_approve_backport: typing.Optional[builtins.bool] = None,
+    backport_branch_name_prefix: typing.Optional[builtins.str] = None,
+    backport_pr_labels: typing.Optional[typing.Sequence[builtins.str]] = None,
+    branches: typing.Optional[typing.Sequence[builtins.str]] = None,
+    create_with_conflicts: typing.Optional[builtins.bool] = None,
+    label_prefix: typing.Optional[builtins.str] = None,
+    workflow_name: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__066696cdba0d516ea035e9580a9e5c79c5a552ca23f78e5291d21811124a2a62(
+    *,
+    auto_approve_backport: typing.Optional[builtins.bool] = None,
+    backport_branch_name_prefix: typing.Optional[builtins.str] = None,
+    backport_pr_labels: typing.Optional[typing.Sequence[builtins.str]] = None,
+    branches: typing.Optional[typing.Sequence[builtins.str]] = None,
+    create_with_conflicts: typing.Optional[builtins.bool] = None,
+    label_prefix: typing.Optional[builtins.str] = None,
+    workflow_name: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__0c1e5279fc8c18480c3113cc60b389aa13938b2052436bbdcb3069cfe669fa47(
     *,
     pull_request_description: builtins.str,
@@ -8013,6 +9911,7 @@ def _typecheckingstub__c3c9a28aa8266154d9a36adad571b3695e958b931e79b9eaff4a7dc55
     *,
     fetch_depth: typing.Optional[jsii.Number] = None,
     lfs: typing.Optional[builtins.bool] = None,
+    path: typing.Optional[builtins.str] = None,
     ref: typing.Optional[builtins.str] = None,
     repository: typing.Optional[builtins.str] = None,
     token: typing.Optional[builtins.str] = None,
@@ -8047,6 +9946,7 @@ def _typecheckingstub__d8786063961cc00764e7c2005db60e7d427b8a81ce2275510888beb4e
 def _typecheckingstub__9d043d0484269cca19493b2d2d5c51f9cfe65a12520148f80ef37f6855457de0(
     *,
     require_scope: typing.Optional[builtins.bool] = None,
+    scopes: typing.Optional[typing.Sequence[builtins.str]] = None,
     types: typing.Optional[typing.Sequence[builtins.str]] = None,
 ) -> None:
     """Type checking stubs"""
@@ -8058,6 +9958,7 @@ def _typecheckingstub__b9e40915fe7c519c231c73e9a63dfa1b1dee67586ebf4629165f8556f
     id: typing.Optional[builtins.str] = None,
     if_: typing.Optional[builtins.str] = None,
     name: typing.Optional[builtins.str] = None,
+    shell: typing.Optional[builtins.str] = None,
     working_directory: typing.Optional[builtins.str] = None,
     continue_on_error: typing.Optional[builtins.bool] = None,
     timeout_minutes: typing.Optional[jsii.Number] = None,
@@ -8114,6 +10015,7 @@ def _typecheckingstub__8d4fb3030e96a87b921aa6bfb0d4ccf7a90d4c2affbcb8eeca2d5a24c
     container: typing.Optional[typing.Union[_ContainerOptions_f50907af, typing.Dict[builtins.str, typing.Any]]] = None,
     download_lfs: typing.Optional[builtins.bool] = None,
     env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    environment: typing.Optional[builtins.str] = None,
     git_identity: typing.Optional[typing.Union[GitIdentity, typing.Dict[builtins.str, typing.Any]]] = None,
     job_defaults: typing.Optional[typing.Union[_JobDefaults_965f0d10, typing.Dict[builtins.str, typing.Any]]] = None,
     outputs: typing.Optional[typing.Mapping[builtins.str, typing.Union[_JobStepOutput_acebe827, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -8137,6 +10039,7 @@ def _typecheckingstub__8e35b96aa7e4fe84c59cac8c7e3f4c146c780c7b09807f610b1aaf727
     container: typing.Optional[typing.Union[_ContainerOptions_f50907af, typing.Dict[builtins.str, typing.Any]]] = None,
     download_lfs: typing.Optional[builtins.bool] = None,
     env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    environment: typing.Optional[builtins.str] = None,
     git_identity: typing.Optional[typing.Union[GitIdentity, typing.Dict[builtins.str, typing.Any]]] = None,
     job_defaults: typing.Optional[typing.Union[_JobDefaults_965f0d10, typing.Dict[builtins.str, typing.Any]]] = None,
     outputs: typing.Optional[typing.Mapping[builtins.str, typing.Union[_JobStepOutput_acebe827, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -8158,6 +10061,7 @@ def _typecheckingstub__4f2039f9f0120fa5bcc0261afed5aa5fd2be59874413018ee781d5e75
     container: typing.Optional[typing.Union[_ContainerOptions_f50907af, typing.Dict[builtins.str, typing.Any]]] = None,
     download_lfs: typing.Optional[builtins.bool] = None,
     env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    environment: typing.Optional[builtins.str] = None,
     git_identity: typing.Optional[typing.Union[GitIdentity, typing.Dict[builtins.str, typing.Any]]] = None,
     job_defaults: typing.Optional[typing.Union[_JobDefaults_965f0d10, typing.Dict[builtins.str, typing.Any]]] = None,
     outputs: typing.Optional[typing.Mapping[builtins.str, typing.Union[_JobStepOutput_acebe827, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -8179,6 +10083,7 @@ def _typecheckingstub__15e1c594f5876baf2e105789fcb541bcb5e71cea5ad4320fb67052a9c
     container: typing.Optional[typing.Union[_ContainerOptions_f50907af, typing.Dict[builtins.str, typing.Any]]] = None,
     download_lfs: typing.Optional[builtins.bool] = None,
     env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    environment: typing.Optional[builtins.str] = None,
     git_identity: typing.Optional[typing.Union[GitIdentity, typing.Dict[builtins.str, typing.Any]]] = None,
     job_defaults: typing.Optional[typing.Union[_JobDefaults_965f0d10, typing.Dict[builtins.str, typing.Any]]] = None,
     outputs: typing.Optional[typing.Mapping[builtins.str, typing.Union[_JobStepOutput_acebe827, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -8201,6 +10106,7 @@ def _typecheckingstub__76a6b70b748b84dc156557f2c93bcd7ad0f6ba6fe077270e3f296f69c
     id: typing.Optional[builtins.str] = None,
     if_: typing.Optional[builtins.str] = None,
     name: typing.Optional[builtins.str] = None,
+    shell: typing.Optional[builtins.str] = None,
     working_directory: typing.Optional[builtins.str] = None,
     continue_on_error: typing.Optional[builtins.bool] = None,
     timeout_minutes: typing.Optional[jsii.Number] = None,
@@ -8214,7 +10120,9 @@ def _typecheckingstub__ffa4e677bfd1bdf4c5e45f5ff5e0b2a238422bb1e8bf6bcf6bbbf0ff2
     path: builtins.str,
     compression_level: typing.Optional[jsii.Number] = None,
     if_no_files_found: typing.Optional[builtins.str] = None,
+    include_hidden_files: typing.Optional[builtins.bool] = None,
     name: typing.Optional[builtins.str] = None,
+    overwrite: typing.Optional[builtins.bool] = None,
     retention_days: typing.Optional[jsii.Number] = None,
 ) -> None:
     """Type checking stubs"""
@@ -8240,7 +10148,11 @@ def _typecheckingstub__696566a4c593a7173649d5eeaadb52edb8460487e95d469374dc3c01f
     id: typing.Optional[builtins.str] = None,
     if_: typing.Optional[builtins.str] = None,
     name: typing.Optional[builtins.str] = None,
+    shell: typing.Optional[builtins.str] = None,
     working_directory: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
     pass
+
+for cls in [IAddConditionsLater]:
+    typing.cast(typing.Any, cls).__protocol_attrs__ = typing.cast(typing.Any, cls).__protocol_attrs__ - set(['__jsii_proxy_class__', '__jsii_type__'])