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

projen/github/__init__.py

@@ -11,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 *
 
@@ -273,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.
@@ -281,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
     '''
 
@@ -440,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],
@@ -448,6 +683,7 @@ class AutoMergeOptions:
         "id": "id",
         "if_": "if",
         "name": "name",
+        "shell": "shell",
         "working_directory": "workingDirectory",
         "continue_on_error": "continueOnError",
         "timeout_minutes": "timeoutMinutes",
@@ -462,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,
@@ -472,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.
@@ -487,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"])
@@ -500,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:
@@ -553,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.
@@ -612,6 +865,7 @@ class CheckoutOptions(_JobStepConfiguration_9caff420):
     name_mapping={
         "fetch_depth": "fetchDepth",
         "lfs": "lfs",
+        "path": "path",
         "ref": "ref",
         "repository": "repository",
         "token": "token",
@@ -623,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,
@@ -631,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
@@ -641,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"])
@@ -649,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:
@@ -680,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.
@@ -734,6 +1004,7 @@ class CheckoutWith:
     name_mapping={
         "fetch_depth": "fetchDepth",
         "lfs": "lfs",
+        "path": "path",
         "ref": "ref",
         "repository": "repository",
         "token": "token",
@@ -746,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,
@@ -755,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
@@ -766,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"])
@@ -775,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:
@@ -808,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.
@@ -867,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=[],
@@ -973,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"
@@ -1103,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
         '''
@@ -1336,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]:
@@ -1372,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.
@@ -1381,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
 
@@ -1393,6 +1806,68 @@ class DependabotGroup:
         )
 
 
+@jsii.enum(jsii_type="projen.github.DependabotGroupAppliesTo")
+class DependabotGroupAppliesTo(enum.Enum):
+    '''(experimental) The type of update a group applies to.
+
+    :stability: experimental
+    '''
+
+    VERSION_UPDATES = "VERSION_UPDATES"
+    '''(experimental) Apply only to version updates.
+
+    :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=[],
@@ -1991,6 +2466,7 @@ class DependabotScheduleInterval(enum.Enum):
         "id": "id",
         "if_": "if",
         "name": "name",
+        "shell": "shell",
         "working_directory": "workingDirectory",
         "continue_on_error": "continueOnError",
         "timeout_minutes": "timeoutMinutes",
@@ -2005,6 +2481,7 @@ class DownloadArtifactOptions(_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,
@@ -2015,6 +2492,7 @@ class DownloadArtifactOptions(_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.
@@ -2030,6 +2508,7 @@ class DownloadArtifactOptions(_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"])
@@ -2045,6 +2524,8 @@ class DownloadArtifactOptions(_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:
@@ -2096,6 +2577,18 @@ class DownloadArtifactOptions(_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.
@@ -2314,6 +2807,8 @@ class GitHub(
         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,
@@ -2327,6 +2822,8 @@ class GitHub(
         '''
         :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
@@ -2344,6 +2841,8 @@ class GitHub(
             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,
@@ -2472,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"))
@@ -2513,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
         '''
@@ -2589,6 +3095,8 @@ 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",
@@ -2605,6 +3113,8 @@ 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,
@@ -2617,6 +3127,8 @@ class GitHubOptions:
     ) -> 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
@@ -2629,6 +3141,8 @@ class GitHubOptions:
 
         :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):
@@ -2638,6 +3152,8 @@ class GitHubOptions:
         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"])
@@ -2650,6 +3166,10 @@ class GitHubOptions:
         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:
@@ -2680,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.
@@ -3653,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.
 
@@ -3662,9 +4208,11 @@ 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
 
@@ -3673,8 +4221,10 @@ class GithubCredentials(
         '''
         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]))
@@ -3729,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:
@@ -3738,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
         '''
@@ -3754,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.
@@ -3785,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
 
@@ -3861,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
         '''
@@ -3876,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])
 
@@ -4088,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.
 
@@ -4099,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"))
@@ -4119,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.
 
-        :default: disabled
+        undefined means no concurrency limitations.
 
         :stability: experimental
         '''
-        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "concurrency"))
+        return typing.cast(typing.Optional[ConcurrencyOptions], jsii.get(self, "concurrency"))
+
+    @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[typing.Mapping[builtins.str, builtins.str]], jsii.get(self, "env"))
 
     @builtins.property
     @jsii.member(jsii_name="file")
@@ -4163,61 +4796,125 @@ 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(self) -> typing.Optional[builtins.str]:
+    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: - disabled
+        :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")
+        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``.
+    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("force")
+        result = self._values.get("limit_concurrency")
         return typing.cast(typing.Optional[builtins.bool], result)
 
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
@@ -4264,6 +4961,160 @@ class _IAddConditionsLaterProxy:
 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
+
+        :stability: experimental
+        '''
+        result = self._values.get("auto_queue")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def auto_queue_options(self) -> typing.Optional[AutoQueueOptions]:
+        '''(experimental) Configure auto-queue pull requests.
+
+        :default: - see AutoQueueOptions
+
+        :stability: experimental
+        '''
+        result = self._values.get("auto_queue_options")
+        return typing.cast(typing.Optional[AutoQueueOptions], result)
+
+    @builtins.property
+    def target_branches(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) The branches that can be merged into using MergeQueue.
+
+        :default: - all branches
+
+        :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 "MergeQueueOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 class Mergify(
     _Component_2b0ad27f,
     metaclass=jsii.JSIIMeta,
@@ -4282,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
         '''
@@ -4298,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,
         )
 
@@ -4416,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__:
@@ -4434,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")
@@ -4442,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")
@@ -4464,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",
     },
 )
@@ -4474,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:
@@ -4525,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.
@@ -4539,6 +5449,18 @@ 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.
@@ -4921,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"
@@ -5070,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
         '''
@@ -5390,6 +6312,7 @@ class PullRequestLintOptions:
     name_mapping={
         "fetch_depth": "fetchDepth",
         "lfs": "lfs",
+        "path": "path",
         "ref": "ref",
         "repository": "repository",
         "token": "token",
@@ -5404,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,
@@ -5414,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
@@ -5427,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"])
@@ -5441,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:
@@ -5474,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.
@@ -5651,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/
@@ -5671,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
 
@@ -5691,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.
@@ -5722,6 +6683,7 @@ class SemanticTitleOptions:
         "id": "id",
         "if_": "if",
         "name": "name",
+        "shell": "shell",
         "working_directory": "workingDirectory",
         "continue_on_error": "continueOnError",
         "timeout_minutes": "timeoutMinutes",
@@ -5736,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,
@@ -5746,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.
@@ -5761,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"])
@@ -5776,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:
@@ -5827,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.
@@ -6228,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,
@@ -6250,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
@@ -6276,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,
@@ -6328,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,
@@ -6347,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
@@ -6370,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,
@@ -6440,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")
@@ -6542,6 +7527,7 @@ class TaskWorkflowJob(
         "container": "container",
         "download_lfs": "downloadLfs",
         "env": "env",
+        "environment": "environment",
         "git_identity": "gitIdentity",
         "job_defaults": "jobDefaults",
         "outputs": "outputs",
@@ -6563,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,
@@ -6581,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
@@ -6613,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"])
@@ -6636,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:
@@ -6726,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")
@@ -6837,6 +7841,7 @@ class TaskWorkflowJobOptions:
         "container": "container",
         "download_lfs": "downloadLfs",
         "env": "env",
+        "environment": "environment",
         "git_identity": "gitIdentity",
         "job_defaults": "jobDefaults",
         "outputs": "outputs",
@@ -6862,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,
@@ -6884,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
@@ -6922,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"])
@@ -6951,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:
@@ -7045,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")
@@ -7195,6 +8218,7 @@ class TaskWorkflowOptions(TaskWorkflowJobOptions):
         "id": "id",
         "if_": "if",
         "name": "name",
+        "shell": "shell",
         "working_directory": "workingDirectory",
         "continue_on_error": "continueOnError",
         "timeout_minutes": "timeoutMinutes",
@@ -7209,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,
@@ -7219,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.
@@ -7234,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"])
@@ -7249,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:
@@ -7300,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.
@@ -7361,6 +8402,7 @@ 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",
@@ -7373,6 +8415,7 @@ 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,
@@ -7381,6 +8424,7 @@ class UploadArtifactWith:
         :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
@@ -7392,6 +8436,7 @@ 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"])
@@ -7402,6 +8447,8 @@ 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:
@@ -7449,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.
@@ -7678,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,
@@ -7687,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
@@ -7699,6 +8761,7 @@ class WorkflowActions(
             patch_file=patch_file,
             fetch_depth=fetch_depth,
             lfs=lfs,
+            path=path,
             ref=ref,
             repository=repository,
             token=token,
@@ -7733,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"
@@ -7866,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"
@@ -7922,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.
@@ -7933,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
@@ -7947,6 +9012,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
             id=id,
             if_=if_,
             name=name,
+            shell=shell,
             working_directory=working_directory,
         )
 
@@ -7964,6 +9030,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) Downloads an artifact.
@@ -7975,6 +9042,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 downloads an artifact
@@ -7989,6 +9057,7 @@ class WorkflowSteps(metaclass=jsii.JSIIMeta, jsii_type="projen.github.WorkflowSt
             id=id,
             if_=if_,
             name=name,
+            shell=shell,
             working_directory=working_directory,
         )
 
@@ -8006,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).
@@ -8017,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
@@ -8031,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,
         )
 
@@ -8048,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.
@@ -8065,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
@@ -8081,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,
         )
 
@@ -8098,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.
@@ -8109,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
@@ -8123,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,
         )
 
@@ -8134,14 +9212,20 @@ __all__ = [
     "AutoApproveOptions",
     "AutoMerge",
     "AutoMergeOptions",
+    "AutoQueue",
+    "AutoQueueOptions",
     "CheckoutOptions",
     "CheckoutWith",
     "CheckoutWithPatchOptions",
+    "ConcurrencyOptions",
     "ContributorStatementOptions",
     "CreatePullRequestOptions",
     "Dependabot",
     "DependabotAllow",
     "DependabotGroup",
+    "DependabotGroupAppliesTo",
+    "DependabotGroupDependencyType",
+    "DependabotGroupUpdateType",
     "DependabotIgnore",
     "DependabotOptions",
     "DependabotRegistry",
@@ -8161,6 +9245,9 @@ __all__ = [
     "GithubWorkflow",
     "GithubWorkflowOptions",
     "IAddConditionsLater",
+    "MergeMethod",
+    "MergeQueue",
+    "MergeQueueOptions",
     "Mergify",
     "MergifyConditionalOperator",
     "MergifyOptions",
@@ -8254,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,
@@ -8272,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,
@@ -8283,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,
@@ -8291,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,
@@ -8359,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
@@ -8410,6 +9536,7 @@ def _typecheckingstub__c7f153d5c1001fcb119385a05448ea85e212f46cc420d578734261b83
     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,
@@ -8435,6 +9562,8 @@ def _typecheckingstub__65db11e8703472c7fa4e013294c649e43b7f8634b29ca11be71b46d8c
     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,
@@ -8488,6 +9617,8 @@ 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,
@@ -8553,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
@@ -8570,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
@@ -8622,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
@@ -8655,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"""
@@ -8750,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,
@@ -8784,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"""
@@ -8795,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,
@@ -8851,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,
@@ -8874,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,
@@ -8895,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,
@@ -8916,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,
@@ -8938,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,
@@ -8951,6 +10120,7 @@ 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,
@@ -8978,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__'])