mrpj 0.2.4 → 0.2.6

package/lib/components/SelfMutationOnForks.js

@@ -0,0 +1,101 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelfMutationOnForks = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+/**
+ * Configures GitHub workflows to enable self-mutation on fork pull requests.
+ *
+ * This class sets up a workflow that will automatically apply projen-generated changes
+ * when a build fails due to outdated generated files. The workflow:
+ *
+ * 1. Runs when the build workflow fails on a PR
+ * 2. Downloads any patch file generated during the failed build
+ * 3. Authenticates using GitHub App credentials
+ * 4. Checks out the PR branch
+ * 5. Applies the patch if it exists and can be applied cleanly
+ * 6. Commits and pushes the changes back to the PR
+ *
+ * This enables automated fixes for common projen-related issues on fork PRs.
+ */
+class SelfMutationOnForks {
+    constructor(project, options = {}) {
+        const cicd = projen_1.github.GitHub.of(project);
+        if (!cicd)
+            return;
+        const buildWorkflow = cicd.tryFindWorkflow('build');
+        if (!buildWorkflow)
+            return;
+        // Update condition to run on all pull requests
+        buildWorkflow.file?.patch(projen_1.JsonPatch.remove('/jobs/self-mutation'));
+        // Add a new self mutation workflow that runs on completion of build
+        // and if the build failed and there is a patch, updates the PR
+        const selfMutation = cicd?.addWorkflow('self-mutation');
+        selfMutation?.on({
+            workflowRun: {
+                workflows: [buildWorkflow.name],
+                types: ['completed'],
+            },
+        });
+        selfMutation?.addJob('self-mutation', {
+            runsOn: ['ubuntu-latest'],
+            if: "github.event.workflow_run.conclusion == 'failure' && github.event.workflow_run.event == 'pull_request'",
+            permissions: {
+                contents: projen_1.github.workflows.JobPermission.READ,
+            },
+            environment: options.environment,
+            steps: [
+                {
+                    name: 'Download patch',
+                    id: 'download_patch',
+                    continueOnError: true,
+                    uses: 'dawidd6/action-download-artifact@ac66b43f0e6a346234dd65d4d0c8fbb31cb316e5',
+                    with: {
+                        run_id: '${{ github.event.workflow_run.id }}',
+                        name: 'repo.patch',
+                        path: '${{ runner.temp }}',
+                    },
+                },
+                ...conditionalSteps('steps.download_patch.outcome == \'success\'', cicd.projenCredentials.setupSteps, projen_1.github.WorkflowSteps.checkout({
+                    name: 'Checkout PR',
+                    with: {
+                        repository: '${{ github.event.workflow_run.head_repository.full_name }}',
+                        ref: '${{ github.event.workflow_run.head_branch }}',
+                        token: cicd.projenCredentials.tokenRef,
+                    },
+                }), {
+                    name: 'Apply patch to PR',
+                    run: [
+                        'set -e',
+                        'if [ ! -f "${{ runner.temp }}/repo.patch" ]; then',
+                        '  echo "Patch file not found"',
+                        '  exit 1',
+                        'fi',
+                        'git config user.name "github-actions[bot]"',
+                        'git config user.email "github-actions[bot]@users.noreply.github.com"',
+                        'if ! git apply --check ${{ runner.temp }}/repo.patch; then',
+                        '  echo "Patch cannot be applied cleanly"',
+                        '  exit 1',
+                        'fi',
+                        'git apply ${{ runner.temp }}/repo.patch',
+                        'if [ -z "$(git status --porcelain)" ]; then',
+                        '  echo "No changes to commit"',
+                        '  exit 0',
+                        'fi',
+                        'git add .',
+                        'git commit -s -m "chore: self mutation"',
+                        'git push',
+                    ].join('\n'),
+                }),
+            ],
+        });
+    }
+}
+exports.SelfMutationOnForks = SelfMutationOnForks;
+_a = JSII_RTTI_SYMBOL_1;
+SelfMutationOnForks[_a] = { fqn: "mrpj.components.SelfMutationOnForks", version: "0.2.6" };
+function conditionalSteps(cond, ...steps) {
+    return steps.flatMap(s => s).map(s => ({ ...s, if: s.if ?? cond }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SelfMutationOnForks.js","sourceRoot":"","sources":["../../src/components/SelfMutationOnForks.ts"],"names":[],"mappings":";;;;;AACA,mCAA2C;AAa3C;;;;;;;;;;;;;;GAcG;AACH,MAAa,mBAAmB;IAC9B,YAAY,OAAgB,EAAE,UAAsC,EAAE;QACpE,MAAM,IAAI,GAAG,eAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC;QACvC,IAAI,CAAC,IAAI;YAAE,OAAO;QAElB,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QACpD,IAAI,CAAC,aAAa;YAAE,OAAO;QAE3B,+CAA+C;QAC/C,aAAa,CAAC,IAAI,EAAE,KAAK,CACvB,kBAAS,CAAC,MAAM,CAAC,qBAAqB,CAAC,CACxC,CAAC;QAEF,oEAAoE;QACpE,+DAA+D;QAC/D,MAAM,YAAY,GAAG,IAAI,EAAE,WAAW,CAAC,eAAe,CAAC,CAAC;QACxD,YAAY,EAAE,EAAE,CAAC;YACf,WAAW,EAAE;gBACX,SAAS,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC;gBAC/B,KAAK,EAAE,CAAC,WAAW,CAAC;aACrB;SACF,CAAC,CAAC;QAEH,YAAY,EAAE,MAAM,CAAC,eAAe,EAAE;YACpC,MAAM,EAAE,CAAC,eAAe,CAAC;YACzB,EAAE,EAAE,wGAAwG;YAC5G,WAAW,EAAE;gBACX,QAAQ,EAAE,eAAM,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI;aAC9C;YACD,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,KAAK,EAAE;gBACL;oBACE,IAAI,EAAE,gBAAgB;oBACtB,EAAE,EAAE,gBAAgB;oBACpB,eAAe,EAAE,IAAI;oBACrB,IAAI,EAAE,2EAA2E;oBACjF,IAAI,EAAE;wBACJ,MAAM,EAAE,qCAAqC;wBAC7C,IAAI,EAAE,YAAY;wBAClB,IAAI,EAAE,oBAAoB;qBAC3B;iBACF;gBACD,GAAG,gBAAgB,CACjB,6CAA6C,EAC7C,IAAI,CAAC,iBAAiB,CAAC,UAAU,EACjC,eAAM,CAAC,aAAa,CAAC,QAAQ,CAAC;oBAC5B,IAAI,EAAE,aAAa;oBACnB,IAAI,EAAE;wBACJ,UAAU,EAAE,4DAA4D;wBACxE,GAAG,EAAE,8CAA8C;wBACnD,KAAK,EAAE,IAAI,CAAC,iBAAiB,CAAC,QAAQ;qBACvC;iBACF,CAAC,EACF;oBACE,IAAI,EAAE,mBAAmB;oBACzB,GAAG,EAAE;wBACH,QAAQ;wBACR,mDAAmD;wBACnD,+BAA+B;wBAC/B,UAAU;wBACV,IAAI;wBACJ,4CAA4C;wBAC5C,sEAAsE;wBACtE,4DAA4D;wBAC5D,0CAA0C;wBAC1C,UAAU;wBACV,IAAI;wBACJ,yCAAyC;wBACzC,6CAA6C;wBAC7C,+BAA+B;wBAC/B,UAAU;wBACV,IAAI;wBACJ,WAAW;wBACX,yCAAyC;wBACzC,UAAU;qBACX,CAAC,IAAI,CAAC,IAAI,CAAC;iBACb,CACF;aACF;SACF,CAAC,CAAC;IACL,CAAC;;AAhFH,kDAiFC;;;AAED,SAAS,gBAAgB,CAAC,IAAY,EAAE,GAAG,KAAmE;IAC5G,OAAO,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC;AACtE,CAAC","sourcesContent":["import type { Project } from 'projen';\nimport { JsonPatch, github } from 'projen';\n\n/**\n * Options for configuring self-mutation behavior on forks\n */\nexport interface SelfMutationOnForksOptions {\n  /**\n   * Environment name to use for the workflow\n   * @default - no environment specified\n   */\n  readonly environment?: string;\n}\n\n/**\n * Configures GitHub workflows to enable self-mutation on fork pull requests.\n *\n * This class sets up a workflow that will automatically apply projen-generated changes\n * when a build fails due to outdated generated files. The workflow:\n *\n * 1. Runs when the build workflow fails on a PR\n * 2. Downloads any patch file generated during the failed build\n * 3. Authenticates using GitHub App credentials\n * 4. Checks out the PR branch\n * 5. Applies the patch if it exists and can be applied cleanly\n * 6. Commits and pushes the changes back to the PR\n *\n * This enables automated fixes for common projen-related issues on fork PRs.\n */\nexport class SelfMutationOnForks {\n  constructor(project: Project, options: SelfMutationOnForksOptions = {}) {\n    const cicd = github.GitHub.of(project);\n    if (!cicd) return;\n\n    const buildWorkflow = cicd.tryFindWorkflow('build');\n    if (!buildWorkflow) return;\n\n    // Update condition to run on all pull requests\n    buildWorkflow.file?.patch(\n      JsonPatch.remove('/jobs/self-mutation'),\n    );\n\n    // Add a new self mutation workflow that runs on completion of build\n    // and if the build failed and there is a patch, updates the PR\n    const selfMutation = cicd?.addWorkflow('self-mutation');\n    selfMutation?.on({\n      workflowRun: {\n        workflows: [buildWorkflow.name],\n        types: ['completed'],\n      },\n    });\n\n    selfMutation?.addJob('self-mutation', {\n      runsOn: ['ubuntu-latest'],\n      if: \"github.event.workflow_run.conclusion == 'failure' && github.event.workflow_run.event == 'pull_request'\",\n      permissions: {\n        contents: github.workflows.JobPermission.READ,\n      },\n      environment: options.environment,\n      steps: [\n        {\n          name: 'Download patch',\n          id: 'download_patch',\n          continueOnError: true,\n          uses: 'dawidd6/action-download-artifact@ac66b43f0e6a346234dd65d4d0c8fbb31cb316e5',\n          with: {\n            run_id: '${{ github.event.workflow_run.id }}',\n            name: 'repo.patch',\n            path: '${{ runner.temp }}',\n          },\n        },\n        ...conditionalSteps(\n          'steps.download_patch.outcome == \\'success\\'',\n          cicd.projenCredentials.setupSteps,\n          github.WorkflowSteps.checkout({\n            name: 'Checkout PR',\n            with: {\n              repository: '${{ github.event.workflow_run.head_repository.full_name }}',\n              ref: '${{ github.event.workflow_run.head_branch }}',\n              token: cicd.projenCredentials.tokenRef,\n            },\n          }),\n          {\n            name: 'Apply patch to PR',\n            run: [\n              'set -e',\n              'if [ ! -f \"${{ runner.temp }}/repo.patch\" ]; then',\n              '  echo \"Patch file not found\"',\n              '  exit 1',\n              'fi',\n              'git config user.name \"github-actions[bot]\"',\n              'git config user.email \"github-actions[bot]@users.noreply.github.com\"',\n              'if ! git apply --check ${{ runner.temp }}/repo.patch; then',\n              '  echo \"Patch cannot be applied cleanly\"',\n              '  exit 1',\n              'fi',\n              'git apply ${{ runner.temp }}/repo.patch',\n              'if [ -z \"$(git status --porcelain)\" ]; then',\n              '  echo \"No changes to commit\"',\n              '  exit 0',\n              'fi',\n              'git add .',\n              'git commit -s -m \"chore: self mutation\"',\n              'git push',\n            ].join('\\n'),\n          },\n        ),\n      ],\n    });\n  }\n}\n\nfunction conditionalSteps(cond: string, ...steps: Array<github.workflows.JobStep | github.workflows.JobStep[]>): github.workflows.JobStep[] {\n  return steps.flatMap(s => s).map(s => ({ ...s, if: s.if ?? cond }));\n}\n"]}

package/lib/components/index.d.ts

@@ -0,0 +1 @@
+export * from './SelfMutationOnForks';

package/lib/components/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./SelfMutationOnForks"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tcG9uZW50cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsd0RBQXNDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9TZWxmTXV0YXRpb25PbkZvcmtzJztcbiJdfQ==

package/lib/construct-project-options.d.ts

@@ -128,9 +128,9 @@ export interface ConstructProjectOptions {
      * NOTE: The jsii compiler releases since 5.0.0 are not semantically versioned
      * and should remain on the same minor, so we recommend using a `~` dependency
      * (e.g. `~5.0.0`).
-     * @default "~5.6.0"
+     * @default "~5.8.0"
      * @stability stable
-     * @pjnew "~5.8.0"
+     * @pjnew "~5.9.0"
      */
     readonly jsiiVersion?: string;
     /**
@@ -266,7 +266,7 @@ export interface ConstructProjectOptions {
     readonly eslintOptions?: javascript.EslintOptions;
     /**
      * Setup eslint.
-     * @default true
+     * @default - true, unless biome is enabled
      * @stability stable
      */
     readonly eslint?: boolean;
@@ -315,7 +315,7 @@ export interface ConstructProjectOptions {
     readonly workflowNodeVersion?: string;
     /**
      * The git identity to use in workflows.
-     * @default - GitHub Actions
+     * @default - default GitHub Actions user
      * @stability stable
      */
     readonly workflowGitIdentity?: github.GitIdentity;
@@ -458,13 +458,13 @@ export interface ConstructProjectOptions {
      */
     readonly copyrightOwner?: string;
     /**
-     * Define the secret name for a specified https://codecov.io/ token A secret is required to send coverage for private repositories.
-     * @default - if this option is not specified, only public repositories are supported
+     * Define the secret name for a specified https://codecov.io/ token.
+     * @default - OIDC auth is used
      * @stability stable
      */
     readonly codeCovTokenSecret?: string;
     /**
-     * Define a GitHub workflow step for sending code coverage metrics to https://codecov.io/ Uses codecov/codecov-action@v4 A secret is required for private repos. Configured with `@codeCovTokenSecret`.
+     * Define a GitHub workflow step for sending code coverage metrics to https://codecov.io/ Uses codecov/codecov-action@v5 By default, OIDC auth is used. Alternatively a token can be provided via `codeCovTokenSecret`.
      * @default false
      * @stability stable
      */
@@ -562,6 +562,12 @@ export interface ConstructProjectOptions {
      * @stability stable
      */
     readonly releaseWorkflowName?: string;
+    /**
+     * Build environment variables for release workflows.
+     * @default {}
+     * @stability stable
+     */
+    readonly releaseWorkflowEnv?: Record<string, string>;
     /**
      * The release trigger to use.
      * @default - Continuous releases (`ReleaseTrigger.continuous()`)
@@ -591,6 +597,17 @@ export interface ConstructProjectOptions {
      * @stability stable
      */
     readonly releaseFailureIssue?: boolean;
+    /**
+     * The GitHub Actions environment used for the release.
+     * This can be used to add an explicit approval step to the release
+     * or limit who can initiate a release through environment protection rules.
+     *
+     * When multiple artifacts are released, the environment can be overwritten
+     * on a per artifact basis.
+     * @default - no environment used, unless set at the artifact level
+     * @stability stable
+     */
+    readonly releaseEnvironment?: string;
     /**
      * Defines additional release branches.
      * A workflow will be created for each
@@ -770,6 +787,12 @@ export interface ConstructProjectOptions {
      * @stability stable
      */
     readonly packageManager?: javascript.NodePackageManager;
+    /**
+     * Use trusted publishing for publishing to npmjs.com Needs to be pre-configured on npm.js to work.
+     * @default - false
+     * @stability stable
+     */
+    readonly npmTrustedPublishing?: boolean;
     /**
      * GitHub secret which contains the NPM token to use when publishing packages.
      * @default "NPM_TOKEN"

package/lib/construct-project-options.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"construct-project-options.js","sourceRoot":"","sources":["../src/construct-project-options.ts"],"names":[],"mappings":"","sourcesContent":["// ~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\".\nimport type { awscdk, cdk, github, GitOptions, GroupRunnerOptions, IgnoreFileOptions, javascript, LoggerOptions, Project, ProjenrcJsonOptions, ReleasableCommits, release, RenovatebotOptions, SampleReadmeProps, typescript } from 'projen';\n\n/**\n * ConstructProjectOptions\n */\nexport interface ConstructProjectOptions {\n  /**\n   * Common options for all AWS Lambda functions.\n   * @default - default options\n   * @stability stable\n   */\n  readonly lambdaOptions?: awscdk.LambdaFunctionCommonOptions;\n  /**\n   * Automatically adds an `awscdk.LambdaExtension` for each `.lambda-extension.ts` entrypoint in your source tree. If this is disabled, you can manually add an `awscdk.AutoDiscover` component to your project.\n   * @default true\n   * @stability stable\n   */\n  readonly lambdaExtensionAutoDiscover?: boolean;\n  /**\n   * Automatically adds an `aws_lambda.Function` for each `.lambda.ts` handler in your source tree. If this is disabled, you either need to explicitly call `aws_lambda.Function.autoDiscover()` or define a `new aws_lambda.Function()` for each handler.\n   * @default true\n   * @stability stable\n   */\n  readonly lambdaAutoDiscover?: boolean;\n  /**\n   * Automatically discovers and creates integration tests for each `.integ.ts` file under your test directory.\n   * @default true\n   * @stability stable\n   */\n  readonly integrationTestAutoDiscover?: boolean;\n  /**\n   * Enable experimental support for the AWS CDK integ-runner.\n   * @default false\n   * @stability stable\n   */\n  readonly experimentalIntegRunner?: boolean;\n  /**\n   * Automatically adds an `cloudfront.experimental.EdgeFunction` for each `.edge-lambda.ts` handler in your source tree. If this is disabled, you can manually add an `awscdk.AutoDiscover` component to your project.\n   * @default true\n   * @stability stable\n   */\n  readonly edgeLambdaAutoDiscover?: boolean;\n  /**\n   * Minimum version of the `constructs` library to depend on.\n   * @default - for CDK 1.x the default is \"3.2.27\", for CDK 2.x the default is\n\"10.0.5\".\n   * @stability stable\n   */\n  readonly constructsVersion?: string;\n  /**\n   * Use pinned version instead of caret version for CDK.\n   * You can use this to prevent mixed versions for your CDK dependencies and to prevent auto-updates.\n   * If you use experimental features this will let you define the moment you include breaking changes.\n   * @stability stable\n   */\n  readonly cdkVersionPinning?: boolean;\n  /**\n   * Version range of the AWS CDK CLI to depend on.\n   * Can be either a specific version, or an NPM version range.\n   *\n   * By default, the latest 2.x version will be installed; you can use this\n   * option to restrict it to a specific version or version range.\n   * @default \"^2\"\n   * @stability stable\n   */\n  readonly cdkCliVersion?: string;\n  /**\n   * Install the assertions library?\n   * Only needed for CDK 1.x. If using CDK 2.x then\n   * assertions is already included in 'aws-cdk-lib'\n   * @default - will be included by default for AWS CDK >= 1.111.0 < 2.0.0\n   * @stability stable\n   */\n  readonly cdkAssertions?: boolean;\n  /**\n   * Minimum version of the AWS CDK to depend on.\n   * @default \"2.1.0\"\n   * @stability stable\n   */\n  readonly cdkVersion: string;\n  /**\n   * Libraries will be picked up by the construct catalog when they are published to npm as jsii modules and will be published under:.\n   * https://awscdk.io/packages/[@SCOPE/]PACKAGE@VERSION\n   *\n   * The catalog will also post a tweet to https://twitter.com/awscdkio with the\n   * package name, description and the above link. You can disable these tweets\n   * through `{ announce: false }`.\n   *\n   * You can also add a Twitter handle through `{ twitter: 'xx' }` which will be\n   * mentioned in the tweet.\n   * @default - new version will be announced\n   * @stability stable\n   */\n  readonly catalog?: cdk.Catalog;\n  /**\n   * @default \".\"\n   * @stability stable\n   */\n  readonly rootdir?: string;\n  /**\n   * Publish to pypi.\n   * @default - no publishing\n   * @stability stable\n   */\n  readonly publishToPypi?: cdk.JsiiPythonTarget;\n  /**\n   * Publish to NuGet.\n   * @default - no publishing\n   * @stability stable\n   */\n  readonly publishToNuget?: cdk.JsiiDotNetTarget;\n  /**\n   * Publish to maven.\n   * @default - no publishing\n   * @stability stable\n   */\n  readonly publishToMaven?: cdk.JsiiJavaTarget;\n  /**\n   * Publish Go bindings to a git repository.\n   * @default - no publishing\n   * @stability stable\n   */\n  readonly publishToGo?: cdk.JsiiGoTarget;\n  /**\n   * Version of the jsii compiler to use.\n   * Set to \"*\" if you want to manually manage the version of jsii in your\n   * project by managing updates to `package.json` on your own.\n   *\n   * NOTE: The jsii compiler releases since 5.0.0 are not semantically versioned\n   * and should remain on the same minor, so we recommend using a `~` dependency\n   * (e.g. `~5.0.0`).\n   * @default \"~5.6.0\"\n   * @stability stable\n   * @pjnew \"~5.8.0\"\n   */\n  readonly jsiiVersion?: string;\n  /**\n   * Accepts a list of glob patterns.\n   * Files matching any of those patterns will be excluded from the TypeScript compiler input.\n   *\n   * By default, jsii will include all *.ts files (except .d.ts files) in the TypeScript compiler input.\n   * This can be problematic for example when the package's build or test procedure generates .ts files\n   * that cannot be compiled with jsii's compiler settings.\n   * @stability stable\n   */\n  readonly excludeTypescript?: Array<string>;\n  /**\n   * File path for generated docs.\n   * @default \"API.md\"\n   * @stability stable\n   */\n  readonly docgenFilePath?: string;\n  /**\n   * Emit a compressed version of the assembly.\n   * @default false\n   * @stability stable\n   */\n  readonly compressAssembly?: boolean;\n  /**\n   * Name of the ignore file for API compatibility tests.\n   * @default \".compatignore\"\n   * @stability stable\n   */\n  readonly compatIgnore?: string;\n  /**\n   * Automatically run API compatibility test against the latest version published to npm after compilation.\n   * - You can manually run compatibility tests using `yarn compat` if this feature is disabled.\n   * - You can ignore compatibility failures by adding lines to a \".compatignore\" file.\n   * @default false\n   * @stability stable\n   */\n  readonly compat?: boolean;\n  /**\n   * Git repository URL.\n   * @default $GIT_REMOTE\n   * @stability stable\n   */\n  readonly repositoryUrl: string;\n  /**\n   * Email or URL of the library author.\n   * @default $GIT_USER_EMAIL\n   * @stability stable\n   */\n  readonly authorAddress: string;\n  /**\n   * The name of the library author.\n   * @default $GIT_USER_NAME\n   * @stability stable\n   */\n  readonly author: string;\n  /**\n   * TypeScript version to use.\n   * NOTE: Typescript is not semantically versioned and should remain on the\n   * same minor, so we recommend using a `~` dependency (e.g. `~1.2.3`).\n   * @default \"latest\"\n   * @stability stable\n   */\n  readonly typescriptVersion?: string;\n  /**\n   * Options for ts-jest.\n   * @stability stable\n   */\n  readonly tsJestOptions?: typescript.TsJestOptions;\n  /**\n   * The name of the development tsconfig.json file.\n   * @default \"tsconfig.dev.json\"\n   * @stability stable\n   */\n  readonly tsconfigDevFile?: string;\n  /**\n   * Custom tsconfig options for the development tsconfig.json file (used for testing).\n   * @default - use the production tsconfig options\n   * @stability stable\n   */\n  readonly tsconfigDev?: javascript.TypescriptConfigOptions;\n  /**\n   * Custom TSConfig.\n   * @default - default options\n   * @stability stable\n   */\n  readonly tsconfig?: javascript.TypescriptConfigOptions;\n  /**\n   * Jest tests directory. Tests files should be named `xxx.test.ts`.\n   * If this directory is under `srcdir` (e.g. `src/test`, `src/__tests__`),\n   * then tests are going to be compiled into `lib/` and executed as javascript.\n   * If the test directory is outside of `src`, then we configure jest to\n   * compile the code in-memory.\n   * @default \"test\"\n   * @stability stable\n   */\n  readonly testdir?: string;\n  /**\n   * Typescript sources directory.\n   * @default \"src\"\n   * @stability stable\n   */\n  readonly srcdir?: string;\n  /**\n   * Generate one-time sample in `src/` and `test/` if there are no files there.\n   * @default true\n   * @stability stable\n   */\n  readonly sampleCode?: boolean;\n  /**\n   * Options for .projenrc.ts.\n   * @stability stable\n   */\n  readonly projenrcTsOptions?: typescript.ProjenrcOptions;\n  /**\n   * Use TypeScript for your projenrc file (`.projenrc.ts`).\n   * @default false\n   * @stability stable\n   * @pjnew true\n   */\n  readonly projenrcTs?: boolean;\n  /**\n   * Typescript  artifacts output directory.\n   * @default \"lib\"\n   * @stability stable\n   */\n  readonly libdir?: string;\n  /**\n   * Eslint options.\n   * @default - opinionated default options\n   * @stability stable\n   */\n  readonly eslintOptions?: javascript.EslintOptions;\n  /**\n   * Setup eslint.\n   * @default true\n   * @stability stable\n   */\n  readonly eslint?: boolean;\n  /**\n   * The .d.ts file that includes the type declarations for this module.\n   * @default - .d.ts file derived from the project's entrypoint (usually lib/index.d.ts)\n   * @stability stable\n   */\n  readonly entrypointTypes?: string;\n  /**\n   * Docs directory.\n   * @default \"docs\"\n   * @stability stable\n   */\n  readonly docsDirectory?: string;\n  /**\n   * Docgen by Typedoc.\n   * @default false\n   * @stability stable\n   */\n  readonly docgen?: boolean;\n  /**\n   * Do not generate a `tsconfig.dev.json` file.\n   * @default false\n   * @stability stable\n   */\n  readonly disableTsconfigDev?: boolean;\n  /**\n   * Do not generate a `tsconfig.json` file (used by jsii projects since tsconfig.json is generated by the jsii compiler).\n   * @default false\n   * @stability stable\n   */\n  readonly disableTsconfig?: boolean;\n  /**\n   * Enable Node.js package cache in GitHub workflows.\n   * @default false\n   * @stability stable\n   */\n  readonly workflowPackageCache?: boolean;\n  /**\n   * The node version used in GitHub Actions workflows.\n   * Always use this option if your GitHub Actions workflows require a specific to run.\n   * @default - `minNodeVersion` if set, otherwise `lts/*`.\n   * @stability stable\n   */\n  readonly workflowNodeVersion?: string;\n  /**\n   * The git identity to use in workflows.\n   * @default - GitHub Actions\n   * @stability stable\n   */\n  readonly workflowGitIdentity?: github.GitIdentity;\n  /**\n   * Workflow steps to use in order to bootstrap this repo.\n   * @default \"yarn install --frozen-lockfile && yarn projen\"\n   * @stability stable\n   */\n  readonly workflowBootstrapSteps?: Array<github.workflows.JobStep>;\n  /**\n   * Automatically release to npm when new versions are introduced.\n   * @default false\n   * @stability stable\n   */\n  readonly releaseToNpm?: boolean;\n  /**\n   * Add release management to this project.\n   * @default - true (false for subprojects)\n   * @stability stable\n   */\n  readonly release?: boolean;\n  /**\n   * The contents of the pull request template.\n   * @default - default content\n   * @stability stable\n   */\n  readonly pullRequestTemplateContents?: Array<string>;\n  /**\n   * Include a GitHub pull request template.\n   * @default true\n   * @stability stable\n   */\n  readonly pullRequestTemplate?: boolean;\n  /**\n   * Version of projen to install.\n   * @default - Defaults to the latest version.\n   * @stability stable\n   */\n  readonly projenVersion?: string;\n  /**\n   * Options for .projenrc.js.\n   * @default - default options\n   * @stability stable\n   */\n  readonly projenrcJsOptions?: javascript.ProjenrcOptions;\n  /**\n   * Generate (once) .projenrc.js (in JavaScript). Set to `false` in order to disable .projenrc.js generation.\n   * @default - true if projenrcJson is false\n   * @stability stable\n   */\n  readonly projenrcJs?: boolean;\n  /**\n   * Indicates of \"projen\" should be installed as a devDependency.\n   * @default - true if not a subproject\n   * @stability stable\n   */\n  readonly projenDevDependency?: boolean;\n  /**\n   * Prettier options.\n   * @default - default options\n   * @stability stable\n   */\n  readonly prettierOptions?: javascript.PrettierOptions;\n  /**\n   * Setup prettier.\n   * @default false\n   * @stability stable\n   */\n  readonly prettier?: boolean;\n  /**\n   * Defines a `package` task that will produce an npm tarball under the artifacts directory (e.g. `dist`).\n   * @default true\n   * @stability stable\n   */\n  readonly package?: boolean;\n  /**\n   * Configuration options for .npmignore file.\n   * @stability stable\n   */\n  readonly npmIgnoreOptions?: IgnoreFileOptions;\n  /**\n   * Defines an .npmignore file. Normally this is only needed for libraries that are packaged as tarballs.\n   * @default true\n   * @stability stable\n   */\n  readonly npmignoreEnabled?: boolean;\n  /**\n   * Jest options.\n   * @default - default options\n   * @stability stable\n   */\n  readonly jestOptions?: javascript.JestOptions;\n  /**\n   * Setup jest unit tests.\n   * @default true\n   * @stability stable\n   */\n  readonly jest?: boolean;\n  /**\n   * Additional entries to .gitignore.\n   * @stability stable\n   */\n  readonly gitignore?: Array<string>;\n  /**\n   * Options for `UpgradeDependencies`.\n   * @default - default options\n   * @stability stable\n   */\n  readonly depsUpgradeOptions?: javascript.UpgradeDependenciesOptions;\n  /**\n   * Use tasks and github workflows to handle dependency upgrades.\n   * Cannot be used in conjunction with `dependabot`.\n   * @default true\n   * @stability stable\n   */\n  readonly depsUpgrade?: boolean;\n  /**\n   * Options for dependabot.\n   * @default - default options\n   * @stability stable\n   */\n  readonly dependabotOptions?: github.DependabotOptions;\n  /**\n   * Use dependabot to handle dependency upgrades.\n   * Cannot be used in conjunction with `depsUpgrade`.\n   * @default false\n   * @stability stable\n   */\n  readonly dependabot?: boolean;\n  /**\n   * The copyright years to put in the LICENSE file.\n   * @default - current year\n   * @stability stable\n   */\n  readonly copyrightPeriod?: string;\n  /**\n   * License copyright owner.\n   * @default - defaults to the value of authorName or \"\" if `authorName` is undefined.\n   * @stability stable\n   */\n  readonly copyrightOwner?: string;\n  /**\n   * Define the secret name for a specified https://codecov.io/ token A secret is required to send coverage for private repositories.\n   * @default - if this option is not specified, only public repositories are supported\n   * @stability stable\n   */\n  readonly codeCovTokenSecret?: string;\n  /**\n   * Define a GitHub workflow step for sending code coverage metrics to https://codecov.io/ Uses codecov/codecov-action@v4 A secret is required for private repos. Configured with `@codeCovTokenSecret`.\n   * @default false\n   * @stability stable\n   */\n  readonly codeCov?: boolean;\n  /**\n   * Configure which licenses should be deemed acceptable for use by dependencies.\n   * This setting will cause the build to fail, if any prohibited or not allowed licenses ares encountered.\n   * @default - no license checks are run during the build and all licenses will be accepted\n   * @stability stable\n   */\n  readonly checkLicenses?: javascript.LicenseCheckerOptions;\n  /**\n   * Options for `Bundler`.\n   * @stability stable\n   */\n  readonly bundlerOptions?: javascript.BundlerOptions;\n  /**\n   * Options for PR build workflow.\n   * @stability stable\n   */\n  readonly buildWorkflowOptions?: javascript.BuildWorkflowOptions;\n  /**\n   * Define a GitHub workflow for building PRs.\n   * @default - true if not a subproject\n   * @stability stable\n   */\n  readonly buildWorkflow?: boolean;\n  /**\n   * Biome options.\n   * @default - default options\n   * @stability stable\n   */\n  readonly biomeOptions?: javascript.BiomeOptions;\n  /**\n   * Setup Biome.\n   * @default false\n   * @stability stable\n   */\n  readonly biome?: boolean;\n  /**\n   * Automatically approve deps upgrade PRs, allowing them to be merged by mergify (if configued).\n   * Throw if set to true but `autoApproveOptions` are not defined.\n   * @default - true\n   * @stability stable\n   */\n  readonly autoApproveUpgrades?: boolean;\n  /**\n   * A directory which will contain build artifacts.\n   * @default \"dist\"\n   * @stability stable\n   */\n  readonly artifactsDirectory?: string;\n  /**\n   * The name of the main release branch.\n   * @default \"main\"\n   * @stability stable\n   */\n  readonly defaultReleaseBranch: string;\n  /**\n   * Github Runner Group selection options.\n   * @stability stable\n   * @description Defines a target Runner Group by name and/or labels\n   * @throws {Error} if both `runsOn` and `runsOnGroup` are specified\n   */\n  readonly workflowRunsOnGroup?: GroupRunnerOptions;\n  /**\n   * Github Runner selection labels.\n   * @default [\"ubuntu-latest\"]\n   * @stability stable\n   * @description Defines a target Runner by labels\n   * @throws {Error} if both `runsOn` and `runsOnGroup` are specified\n   */\n  readonly workflowRunsOn?: Array<string>;\n  /**\n   * Container image to use for GitHub workflows.\n   * @default - default image\n   * @stability stable\n   */\n  readonly workflowContainerImage?: string;\n  /**\n   * Custom configuration used when creating changelog with commit-and-tag-version package.\n   * Given values either append to default configuration or overwrite values in it.\n   * @default - standard configuration applicable for GitHub repositories\n   * @stability stable\n   */\n  readonly versionrcOptions?: Record<string, any>;\n  /**\n   * A set of workflow steps to execute in order to setup the workflow container.\n   * @stability stable\n   */\n  readonly releaseWorkflowSetupSteps?: Array<github.workflows.JobStep>;\n  /**\n   * The name of the default release workflow.\n   * @default \"release\"\n   * @stability stable\n   */\n  readonly releaseWorkflowName?: string;\n  /**\n   * The release trigger to use.\n   * @default - Continuous releases (`ReleaseTrigger.continuous()`)\n   * @stability stable\n   */\n  readonly releaseTrigger?: release.ReleaseTrigger;\n  /**\n   * Automatically add the given prefix to release tags. Useful if you are releasing on multiple branches with overlapping version numbers.\n   * Note: this prefix is used to detect the latest tagged version\n   * when bumping, so if you change this on a project with an existing version\n   * history, you may need to manually tag your latest release\n   * with the new prefix.\n   * @default \"v\"\n   * @stability stable\n   */\n  readonly releaseTagPrefix?: string;\n  /**\n   * The label to apply to issues indicating publish failures.\n   * Only applies if `releaseFailureIssue` is true.\n   * @default \"failed-release\"\n   * @stability stable\n   */\n  readonly releaseFailureIssueLabel?: string;\n  /**\n   * Create a github issue on every failed publishing task.\n   * @default false\n   * @stability stable\n   */\n  readonly releaseFailureIssue?: boolean;\n  /**\n   * Defines additional release branches.\n   * A workflow will be created for each\n   * release branch which will publish releases from commits in this branch.\n   * Each release branch _must_ be assigned a major version number which is used\n   * to enforce that versions published from that branch always use that major\n   * version. If multiple branches are used, the `majorVersion` field must also\n   * be provided for the default branch.\n   * @default - no additional branches are used for release. you can use\n`addBranch()` to add additional branches.\n   * @stability stable\n   */\n  readonly releaseBranches?: Record<string, release.BranchOptions>;\n  /**\n   * Find commits that should be considered releasable Used to decide if a release is required.\n   * @default ReleasableCommits.everyCommit()\n   * @stability stable\n   */\n  readonly releasableCommits?: ReleasableCommits;\n  /**\n   * Define publishing tasks that can be executed manually as well as workflows.\n   * Normally, publishing only happens within automated workflows. Enable this\n   * in order to create a publishing task for each publishing activity.\n   * @default false\n   * @stability stable\n   */\n  readonly publishTasks?: boolean;\n  /**\n   * Instead of actually publishing to package managers, just print the publishing command.\n   * @default false\n   * @stability stable\n   */\n  readonly publishDryRun?: boolean;\n  /**\n   * Bump versions from the default branch as pre-releases (e.g. \"beta\", \"alpha\", \"pre\").\n   * @default - normal semantic versions\n   * @stability stable\n   */\n  readonly prerelease?: string;\n  /**\n   * Steps to execute after build as part of the release workflow.\n   * @default []\n   * @stability stable\n   */\n  readonly postBuildSteps?: Array<github.workflows.JobStep>;\n  /**\n   * The npmDistTag to use when publishing from the default branch.\n   * To set the npm dist-tag for release branches, set the `npmDistTag` property\n   * for each branch.\n   * @default \"latest\"\n   * @stability stable\n   */\n  readonly npmDistTag?: string;\n  /**\n   * A shell command to control the next version to release.\n   * If present, this shell command will be run before the bump is executed, and\n   * it determines what version to release. It will be executed in the following\n   * environment:\n   *\n   * - Working directory: the project directory.\n   * - `$VERSION`: the current version. Looks like `1.2.3`.\n   * - `$LATEST_TAG`: the most recent tag. Looks like `prefix-v1.2.3`, or may be unset.\n   * - `$SUGGESTED_BUMP`: the suggested bump action based on commits. One of `major|minor|patch|none`.\n   *\n   * The command should print one of the following to `stdout`:\n   *\n   * - Nothing: the next version number will be determined based on commit history.\n   * - `x.y.z`: the next version number will be `x.y.z`.\n   * - `major|minor|patch`: the next version number will be the current version number\n   *   with the indicated component bumped.\n   *\n   * This setting cannot be specified together with `minMajorVersion`; the invoked\n   * script can be used to achieve the effects of `minMajorVersion`.\n   * @default - The next version will be determined based on the commit history and project settings.\n   * @stability stable\n   */\n  readonly nextVersionCommand?: string;\n  /**\n   * Minimal Major version to release.\n   * This can be useful to set to 1, as breaking changes before the 1.x major\n   * release are not incrementing the major version number.\n   *\n   * Can not be set together with `majorVersion`.\n   * @default - No minimum version is being enforced\n   * @stability stable\n   */\n  readonly minMajorVersion?: number;\n  /**\n   * Major version to release from the default branch.\n   * If this is specified, we bump the latest version of this major version line.\n   * If not specified, we bump the global latest version.\n   * @default - Major version is not enforced.\n   * @stability stable\n   */\n  readonly majorVersion?: number;\n  /**\n   * Version requirement of `publib` which is used to publish modules to npm.\n   * @default \"latest\"\n   * @stability stable\n   */\n  readonly jsiiReleaseVersion?: string;\n  /**\n   * The `commit-and-tag-version` compatible package used to bump the package version, as a dependency string.\n   * This can be any compatible package version, including the deprecated `standard-version@9`.\n   * @default - A recent version of \"commit-and-tag-version\"\n   * @stability stable\n   */\n  readonly bumpPackage?: string;\n  /**\n   * Options for Yarn Berry.\n   * @default - Yarn Berry v4 with all default options\n   * @stability stable\n   */\n  readonly yarnBerryOptions?: javascript.YarnBerryOptions;\n  /**\n   * Package's Stability.\n   * @stability stable\n   */\n  readonly stability?: string;\n  /**\n   * Options for privately hosted scoped packages.\n   * @default - fetch all scoped packages from the public npm registry\n   * @stability stable\n   */\n  readonly scopedPackagesOptions?: Array<javascript.ScopedPackagesOptions>;\n  /**\n   * If the package.json for your package is not in the root directory (for example if it is part of a monorepo), you can specify the directory in which it lives.\n   * @stability stable\n   */\n  readonly repositoryDirectory?: string;\n  /**\n   * The repository is the location where the actual code for your package lives.\n   * See https://classic.yarnpkg.com/en/docs/package-json/#toc-repository\n   * @stability stable\n   */\n  readonly repository?: string;\n  /**\n   * The version of PNPM to use if using PNPM as a package manager.\n   * @default \"9\"\n   * @stability stable\n   */\n  readonly pnpmVersion?: string;\n  /**\n   * Peer dependencies for this module.\n   * Dependencies listed here are required to\n   * be installed (and satisfied) by the _consumer_ of this library. Using peer\n   * dependencies allows you to ensure that only a single module of a certain\n   * library exists in the `node_modules` tree of your consumers.\n   *\n   * Note that prior to npm@7, peer dependencies are _not_ automatically\n   * installed, which means that adding peer dependencies to a library will be a\n   * breaking change for your customers.\n   *\n   * Unless `peerDependencyOptions.pinnedDevDependency` is disabled (it is\n   * enabled by default), projen will automatically add a dev dependency with a\n   * pinned version for each peer dependency. This will ensure that you build &\n   * test your module against the lowest peer version required.\n   * @default []\n   * @stability stable\n   */\n  readonly peerDeps?: Array<string>;\n  /**\n   * Options for `peerDeps`.\n   * @stability stable\n   */\n  readonly peerDependencyOptions?: javascript.PeerDependencyOptions;\n  /**\n   * The \"name\" in package.json.\n   * @default - defaults to project name\n   * @stability stable\n   * @featured true\n   */\n  readonly packageName?: string;\n  /**\n   * The Node Package Manager used to execute scripts.\n   * @default NodePackageManager.YARN_CLASSIC\n   * @stability stable\n   */\n  readonly packageManager?: javascript.NodePackageManager;\n  /**\n   * GitHub secret which contains the NPM token to use when publishing packages.\n   * @default \"NPM_TOKEN\"\n   * @stability stable\n   */\n  readonly npmTokenSecret?: string;\n  /**\n   * The base URL of the npm package registry.\n   * Must be a URL (e.g. start with \"https://\" or \"http://\")\n   * @default \"https://registry.npmjs.org\"\n   * @stability stable\n   */\n  readonly npmRegistryUrl?: string;\n  /**\n   * Should provenance statements be generated when the package is published.\n   * A supported package manager is required to publish a package with npm provenance statements and\n   * you will need to use a supported CI/CD provider.\n   *\n   * Note that the projen `Release` and `Publisher` components are using `publib` to publish packages,\n   * which is using npm internally and supports provenance statements independently of the package manager used.\n   * @default - true for public packages, false otherwise\n   * @stability stable\n   */\n  readonly npmProvenance?: boolean;\n  /**\n   * Access level of the npm package.\n   * @default - for scoped packages (e.g. `foo@bar`), the default is\n`NpmAccess.RESTRICTED`, for non-scoped packages, the default is\n`NpmAccess.PUBLIC`.\n   * @stability stable\n   */\n  readonly npmAccess?: javascript.NpmAccess;\n  /**\n   * The minimum node version required by this package to function. Most projects should not use this option.\n   * The value indicates that the package is incompatible with any older versions of node.\n   * This requirement is enforced via the engines field.\n   *\n   * You will normally not need to set this option, even if your package is incompatible with EOL versions of node.\n   * Consider this option only if your package depends on a specific feature, that is not available in other LTS versions.\n   * Setting this option has very high impact on the consumers of your package,\n   * as package managers will actively prevent usage with node versions you have marked as incompatible.\n   *\n   * To change the node version of your CI/CD workflows, use `workflowNodeVersion`.\n   * @default - no minimum version is enforced\n   * @stability stable\n   */\n  readonly minNodeVersion?: string;\n  /**\n   * The maximum node version supported by this package. Most projects should not use this option.\n   * The value indicates that the package is incompatible with any newer versions of node.\n   * This requirement is enforced via the engines field.\n   *\n   * You will normally not need to set this option.\n   * Consider this option only if your package is known to not function with newer versions of node.\n   * @default - no maximum version is enforced\n   * @stability stable\n   */\n  readonly maxNodeVersion?: string;\n  /**\n   * Indicates if a license should be added.\n   * @default true\n   * @stability stable\n   */\n  readonly licensed?: boolean;\n  /**\n   * License's SPDX identifier.\n   * See https://github.com/projen/projen/tree/main/license-text for a list of supported licenses.\n   * Use the `licensed` option if you want to no license to be specified.\n   * @default \"Apache-2.0\"\n   * @stability stable\n   */\n  readonly license?: string;\n  /**\n   * Keywords to include in `package.json`.\n   * @stability stable\n   */\n  readonly keywords?: Array<string>;\n  /**\n   * Package's Homepage / Website.\n   * @stability stable\n   */\n  readonly homepage?: string;\n  /**\n   * Module entrypoint (`main` in `package.json`).\n   * Set to an empty string to not include `main` in your package.json\n   * @default \"lib/index.js\"\n   * @stability stable\n   */\n  readonly entrypoint?: string;\n  /**\n   * Build dependencies for this module.\n   * These dependencies will only be\n   * available in your build environment but will not be fetched when this\n   * module is consumed.\n   *\n   * The recommendation is to only specify the module name here (e.g.\n   * `express`). This will behave similar to `yarn add` or `npm install` in the\n   * sense that it will add the module as a dependency to your `package.json`\n   * file with the latest version (`^`). You can specify semver requirements in\n   * the same syntax passed to `npm i` or `yarn add` (e.g. `express@^2`) and\n   * this will be what you `package.json` will eventually include.\n   * @default []\n   * @stability stable\n   * @featured true\n   */\n  readonly devDeps?: Array<string>;\n  /**\n   * The description is just a string that helps people understand the purpose of the package.\n   * It can be used when searching for packages in a package manager as well.\n   * See https://classic.yarnpkg.com/en/docs/package-json/#toc-description\n   * @stability stable\n   * @featured true\n   */\n  readonly description?: string;\n  /**\n   * Runtime dependencies of this module.\n   * The recommendation is to only specify the module name here (e.g.\n   * `express`). This will behave similar to `yarn add` or `npm install` in the\n   * sense that it will add the module as a dependency to your `package.json`\n   * file with the latest version (`^`). You can specify semver requirements in\n   * the same syntax passed to `npm i` or `yarn add` (e.g. `express@^2`) and\n   * this will be what you `package.json` will eventually include.\n   * @default []\n   * @stability stable\n   * @featured true\n   */\n  readonly deps?: Array<string>;\n  /**\n   * Options for npm packages using AWS CodeArtifact.\n   * This is required if publishing packages to, or installing scoped packages from AWS CodeArtifact\n   * @default - undefined\n   * @stability stable\n   */\n  readonly codeArtifactOptions?: javascript.CodeArtifactOptions;\n  /**\n   * The version of Bun to use if using Bun as a package manager.\n   * @default \"latest\"\n   * @stability stable\n   */\n  readonly bunVersion?: string;\n  /**\n   * List of dependencies to bundle into this module.\n   * These modules will be\n   * added both to the `dependencies` section and `bundledDependencies` section of\n   * your `package.json`.\n   *\n   * The recommendation is to only specify the module name here (e.g.\n   * `express`). This will behave similar to `yarn add` or `npm install` in the\n   * sense that it will add the module as a dependency to your `package.json`\n   * file with the latest version (`^`). You can specify semver requirements in\n   * the same syntax passed to `npm i` or `yarn add` (e.g. `express@^2`) and\n   * this will be what you `package.json` will eventually include.\n   * @stability stable\n   */\n  readonly bundledDeps?: Array<string>;\n  /**\n   * The url to your project's issue tracker.\n   * @stability stable\n   */\n  readonly bugsUrl?: string;\n  /**\n   * The email address to which issues should be reported.\n   * @stability stable\n   */\n  readonly bugsEmail?: string;\n  /**\n   * Binary programs vended with your module.\n   * You can use this option to add/customize how binaries are represented in\n   * your `package.json`, but unless `autoDetectBin` is `false`, every\n   * executable file under `bin` will automatically be added to this section.\n   * @stability stable\n   */\n  readonly bin?: Record<string, string>;\n  /**\n   * Automatically add all executables under the `bin` directory to your `package.json` file under the `bin` section.\n   * @default true\n   * @stability stable\n   */\n  readonly autoDetectBin?: boolean;\n  /**\n   * Author's URL / Website.\n   * @stability stable\n   */\n  readonly authorUrl?: string;\n  /**\n   * Is the author an organization.\n   * @stability stable\n   */\n  readonly authorOrganization?: boolean;\n  /**\n   * Author's name.\n   * @stability stable\n   */\n  readonly authorName?: string;\n  /**\n   * Author's e-mail.\n   * @stability stable\n   */\n  readonly authorEmail?: string;\n  /**\n   * Allow the project to include `peerDependencies` and `bundledDependencies`.\n   * This is normally only allowed for libraries. For apps, there's no meaning\n   * for specifying these.\n   * @default true\n   * @stability stable\n   */\n  readonly allowLibraryDependencies?: boolean;\n  /**\n   * Enable VSCode integration.\n   * Enabled by default for root projects. Disabled for non-root projects.\n   * @default true\n   * @stability stable\n   */\n  readonly vscode?: boolean;\n  /**\n   * Auto-close stale issues and pull requests.\n   * To disable set `stale` to `false`.\n   * @default - see defaults in `StaleOptions`\n   * @stability stable\n   */\n  readonly staleOptions?: github.StaleOptions;\n  /**\n   * Auto-close of stale issues and pull request.\n   * See `staleOptions` for options.\n   * @default false\n   * @stability stable\n   */\n  readonly stale?: boolean;\n  /**\n   * The README setup.\n   * @default - { filename: 'README.md', contents: '# replace this' }\n   * @stability stable\n   */\n  readonly readme?: SampleReadmeProps;\n  /**\n   * Choose a method of providing GitHub API access for projen workflows.\n   * @default - use a personal access token named PROJEN_GITHUB_TOKEN\n   * @stability stable\n   */\n  readonly projenCredentials?: github.GithubCredentials;\n  /**\n   * Add a Gitpod development environment.\n   * @default false\n   * @stability stable\n   */\n  readonly gitpod?: boolean;\n  /**\n   * Options for GitHub integration.\n   * @default - see GitHubOptions\n   * @stability stable\n   */\n  readonly githubOptions?: github.GitHubOptions;\n  /**\n   * Enable GitHub integration.\n   * Enabled by default for root projects. Disabled for non-root projects.\n   * @default true\n   * @stability stable\n   */\n  readonly github?: boolean;\n  /**\n   * Add a VSCode development environment (used for GitHub Codespaces).\n   * @default false\n   * @stability stable\n   */\n  readonly devContainer?: boolean;\n  /**\n   * Add a `clobber` task which resets the repo to origin.\n   * @default - true, but false for subprojects\n   * @stability stable\n   */\n  readonly clobber?: boolean;\n  /**\n   * Configure options for automatic merging on GitHub.\n   * Has no effect if\n   * `github.mergify` or `autoMerge` is set to false.\n   * @default - see defaults in `AutoMergeOptions`\n   * @stability stable\n   */\n  readonly autoMergeOptions?: github.AutoMergeOptions;\n  /**\n   * Enable automatic merging on GitHub.\n   * Has no effect if `github.mergify`\n   * is set to false.\n   * @default true\n   * @stability stable\n   */\n  readonly autoMerge?: boolean;\n  /**\n   * Enable and configure the 'auto approve' workflow.\n   * @default - auto approve is disabled\n   * @stability stable\n   */\n  readonly autoApproveOptions?: github.AutoApproveOptions;\n  /**\n   * Options for renovatebot.\n   * @default - default options\n   * @stability stable\n   */\n  readonly renovatebotOptions?: RenovatebotOptions;\n  /**\n   * Use renovatebot to handle dependency upgrades.\n   * @default false\n   * @stability stable\n   */\n  readonly renovatebot?: boolean;\n  /**\n   * Options for .projenrc.json.\n   * @default - default options\n   * @stability stable\n   */\n  readonly projenrcJsonOptions?: ProjenrcJsonOptions;\n  /**\n   * Generate (once) .projenrc.json (in JSON). Set to `false` in order to disable .projenrc.json generation.\n   * @default false\n   * @stability stable\n   */\n  readonly projenrcJson?: boolean;\n  /**\n   * The shell command to use in order to run the projen CLI.\n   * Can be used to customize in special environments.\n   * @default \"npx projen\"\n   * @stability stable\n   */\n  readonly projenCommand?: string;\n  /**\n   * The parent project, if this project is part of a bigger project.\n   * @stability stable\n   */\n  readonly parent?: Project;\n  /**\n   * The root directory of the project.\n   * Relative to this directory, all files are synthesized.\n   *\n   * If this project has a parent, this directory is relative to the parent\n   * directory and it cannot be the same as the parent or any of it's other\n   * subprojects.\n   * @default \".\"\n   * @stability stable\n   */\n  readonly outdir?: string;\n  /**\n   * Configure logging options such as verbosity.\n   * @default {}\n   * @stability stable\n   */\n  readonly logging?: LoggerOptions;\n  /**\n   * Configuration options for git.\n   * @stability stable\n   */\n  readonly gitOptions?: GitOptions;\n  /**\n   * Configuration options for .gitignore file.\n   * @stability stable\n   */\n  readonly gitIgnoreOptions?: IgnoreFileOptions;\n  /**\n   * Whether to commit the managed files by default.\n   * @default true\n   * @stability stable\n   */\n  readonly commitGenerated?: boolean;\n  /**\n   * This is the name of your project.\n   * @default $BASEDIR\n   * @stability stable\n   * @featured true\n   */\n  readonly name: string;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"construct-project-options.js","sourceRoot":"","sources":["../src/construct-project-options.ts"],"names":[],"mappings":"","sourcesContent":["// ~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\".\nimport type { awscdk, cdk, github, GitOptions, GroupRunnerOptions, IgnoreFileOptions, javascript, LoggerOptions, Project, ProjenrcJsonOptions, ReleasableCommits, release, RenovatebotOptions, SampleReadmeProps, typescript } from 'projen';\n\n/**\n * ConstructProjectOptions\n */\nexport interface ConstructProjectOptions {\n  /**\n   * Common options for all AWS Lambda functions.\n   * @default - default options\n   * @stability stable\n   */\n  readonly lambdaOptions?: awscdk.LambdaFunctionCommonOptions;\n  /**\n   * Automatically adds an `awscdk.LambdaExtension` for each `.lambda-extension.ts` entrypoint in your source tree. If this is disabled, you can manually add an `awscdk.AutoDiscover` component to your project.\n   * @default true\n   * @stability stable\n   */\n  readonly lambdaExtensionAutoDiscover?: boolean;\n  /**\n   * Automatically adds an `aws_lambda.Function` for each `.lambda.ts` handler in your source tree. If this is disabled, you either need to explicitly call `aws_lambda.Function.autoDiscover()` or define a `new aws_lambda.Function()` for each handler.\n   * @default true\n   * @stability stable\n   */\n  readonly lambdaAutoDiscover?: boolean;\n  /**\n   * Automatically discovers and creates integration tests for each `.integ.ts` file under your test directory.\n   * @default true\n   * @stability stable\n   */\n  readonly integrationTestAutoDiscover?: boolean;\n  /**\n   * Enable experimental support for the AWS CDK integ-runner.\n   * @default false\n   * @stability stable\n   */\n  readonly experimentalIntegRunner?: boolean;\n  /**\n   * Automatically adds an `cloudfront.experimental.EdgeFunction` for each `.edge-lambda.ts` handler in your source tree. If this is disabled, you can manually add an `awscdk.AutoDiscover` component to your project.\n   * @default true\n   * @stability stable\n   */\n  readonly edgeLambdaAutoDiscover?: boolean;\n  /**\n   * Minimum version of the `constructs` library to depend on.\n   * @default - for CDK 1.x the default is \"3.2.27\", for CDK 2.x the default is\n\"10.0.5\".\n   * @stability stable\n   */\n  readonly constructsVersion?: string;\n  /**\n   * Use pinned version instead of caret version for CDK.\n   * You can use this to prevent mixed versions for your CDK dependencies and to prevent auto-updates.\n   * If you use experimental features this will let you define the moment you include breaking changes.\n   * @stability stable\n   */\n  readonly cdkVersionPinning?: boolean;\n  /**\n   * Version range of the AWS CDK CLI to depend on.\n   * Can be either a specific version, or an NPM version range.\n   *\n   * By default, the latest 2.x version will be installed; you can use this\n   * option to restrict it to a specific version or version range.\n   * @default \"^2\"\n   * @stability stable\n   */\n  readonly cdkCliVersion?: string;\n  /**\n   * Install the assertions library?\n   * Only needed for CDK 1.x. If using CDK 2.x then\n   * assertions is already included in 'aws-cdk-lib'\n   * @default - will be included by default for AWS CDK >= 1.111.0 < 2.0.0\n   * @stability stable\n   */\n  readonly cdkAssertions?: boolean;\n  /**\n   * Minimum version of the AWS CDK to depend on.\n   * @default \"2.1.0\"\n   * @stability stable\n   */\n  readonly cdkVersion: string;\n  /**\n   * Libraries will be picked up by the construct catalog when they are published to npm as jsii modules and will be published under:.\n   * https://awscdk.io/packages/[@SCOPE/]PACKAGE@VERSION\n   *\n   * The catalog will also post a tweet to https://twitter.com/awscdkio with the\n   * package name, description and the above link. You can disable these tweets\n   * through `{ announce: false }`.\n   *\n   * You can also add a Twitter handle through `{ twitter: 'xx' }` which will be\n   * mentioned in the tweet.\n   * @default - new version will be announced\n   * @stability stable\n   */\n  readonly catalog?: cdk.Catalog;\n  /**\n   * @default \".\"\n   * @stability stable\n   */\n  readonly rootdir?: string;\n  /**\n   * Publish to pypi.\n   * @default - no publishing\n   * @stability stable\n   */\n  readonly publishToPypi?: cdk.JsiiPythonTarget;\n  /**\n   * Publish to NuGet.\n   * @default - no publishing\n   * @stability stable\n   */\n  readonly publishToNuget?: cdk.JsiiDotNetTarget;\n  /**\n   * Publish to maven.\n   * @default - no publishing\n   * @stability stable\n   */\n  readonly publishToMaven?: cdk.JsiiJavaTarget;\n  /**\n   * Publish Go bindings to a git repository.\n   * @default - no publishing\n   * @stability stable\n   */\n  readonly publishToGo?: cdk.JsiiGoTarget;\n  /**\n   * Version of the jsii compiler to use.\n   * Set to \"*\" if you want to manually manage the version of jsii in your\n   * project by managing updates to `package.json` on your own.\n   *\n   * NOTE: The jsii compiler releases since 5.0.0 are not semantically versioned\n   * and should remain on the same minor, so we recommend using a `~` dependency\n   * (e.g. `~5.0.0`).\n   * @default \"~5.8.0\"\n   * @stability stable\n   * @pjnew \"~5.9.0\"\n   */\n  readonly jsiiVersion?: string;\n  /**\n   * Accepts a list of glob patterns.\n   * Files matching any of those patterns will be excluded from the TypeScript compiler input.\n   *\n   * By default, jsii will include all *.ts files (except .d.ts files) in the TypeScript compiler input.\n   * This can be problematic for example when the package's build or test procedure generates .ts files\n   * that cannot be compiled with jsii's compiler settings.\n   * @stability stable\n   */\n  readonly excludeTypescript?: Array<string>;\n  /**\n   * File path for generated docs.\n   * @default \"API.md\"\n   * @stability stable\n   */\n  readonly docgenFilePath?: string;\n  /**\n   * Emit a compressed version of the assembly.\n   * @default false\n   * @stability stable\n   */\n  readonly compressAssembly?: boolean;\n  /**\n   * Name of the ignore file for API compatibility tests.\n   * @default \".compatignore\"\n   * @stability stable\n   */\n  readonly compatIgnore?: string;\n  /**\n   * Automatically run API compatibility test against the latest version published to npm after compilation.\n   * - You can manually run compatibility tests using `yarn compat` if this feature is disabled.\n   * - You can ignore compatibility failures by adding lines to a \".compatignore\" file.\n   * @default false\n   * @stability stable\n   */\n  readonly compat?: boolean;\n  /**\n   * Git repository URL.\n   * @default $GIT_REMOTE\n   * @stability stable\n   */\n  readonly repositoryUrl: string;\n  /**\n   * Email or URL of the library author.\n   * @default $GIT_USER_EMAIL\n   * @stability stable\n   */\n  readonly authorAddress: string;\n  /**\n   * The name of the library author.\n   * @default $GIT_USER_NAME\n   * @stability stable\n   */\n  readonly author: string;\n  /**\n   * TypeScript version to use.\n   * NOTE: Typescript is not semantically versioned and should remain on the\n   * same minor, so we recommend using a `~` dependency (e.g. `~1.2.3`).\n   * @default \"latest\"\n   * @stability stable\n   */\n  readonly typescriptVersion?: string;\n  /**\n   * Options for ts-jest.\n   * @stability stable\n   */\n  readonly tsJestOptions?: typescript.TsJestOptions;\n  /**\n   * The name of the development tsconfig.json file.\n   * @default \"tsconfig.dev.json\"\n   * @stability stable\n   */\n  readonly tsconfigDevFile?: string;\n  /**\n   * Custom tsconfig options for the development tsconfig.json file (used for testing).\n   * @default - use the production tsconfig options\n   * @stability stable\n   */\n  readonly tsconfigDev?: javascript.TypescriptConfigOptions;\n  /**\n   * Custom TSConfig.\n   * @default - default options\n   * @stability stable\n   */\n  readonly tsconfig?: javascript.TypescriptConfigOptions;\n  /**\n   * Jest tests directory. Tests files should be named `xxx.test.ts`.\n   * If this directory is under `srcdir` (e.g. `src/test`, `src/__tests__`),\n   * then tests are going to be compiled into `lib/` and executed as javascript.\n   * If the test directory is outside of `src`, then we configure jest to\n   * compile the code in-memory.\n   * @default \"test\"\n   * @stability stable\n   */\n  readonly testdir?: string;\n  /**\n   * Typescript sources directory.\n   * @default \"src\"\n   * @stability stable\n   */\n  readonly srcdir?: string;\n  /**\n   * Generate one-time sample in `src/` and `test/` if there are no files there.\n   * @default true\n   * @stability stable\n   */\n  readonly sampleCode?: boolean;\n  /**\n   * Options for .projenrc.ts.\n   * @stability stable\n   */\n  readonly projenrcTsOptions?: typescript.ProjenrcOptions;\n  /**\n   * Use TypeScript for your projenrc file (`.projenrc.ts`).\n   * @default false\n   * @stability stable\n   * @pjnew true\n   */\n  readonly projenrcTs?: boolean;\n  /**\n   * Typescript  artifacts output directory.\n   * @default \"lib\"\n   * @stability stable\n   */\n  readonly libdir?: string;\n  /**\n   * Eslint options.\n   * @default - opinionated default options\n   * @stability stable\n   */\n  readonly eslintOptions?: javascript.EslintOptions;\n  /**\n   * Setup eslint.\n   * @default - true, unless biome is enabled\n   * @stability stable\n   */\n  readonly eslint?: boolean;\n  /**\n   * The .d.ts file that includes the type declarations for this module.\n   * @default - .d.ts file derived from the project's entrypoint (usually lib/index.d.ts)\n   * @stability stable\n   */\n  readonly entrypointTypes?: string;\n  /**\n   * Docs directory.\n   * @default \"docs\"\n   * @stability stable\n   */\n  readonly docsDirectory?: string;\n  /**\n   * Docgen by Typedoc.\n   * @default false\n   * @stability stable\n   */\n  readonly docgen?: boolean;\n  /**\n   * Do not generate a `tsconfig.dev.json` file.\n   * @default false\n   * @stability stable\n   */\n  readonly disableTsconfigDev?: boolean;\n  /**\n   * Do not generate a `tsconfig.json` file (used by jsii projects since tsconfig.json is generated by the jsii compiler).\n   * @default false\n   * @stability stable\n   */\n  readonly disableTsconfig?: boolean;\n  /**\n   * Enable Node.js package cache in GitHub workflows.\n   * @default false\n   * @stability stable\n   */\n  readonly workflowPackageCache?: boolean;\n  /**\n   * The node version used in GitHub Actions workflows.\n   * Always use this option if your GitHub Actions workflows require a specific to run.\n   * @default - `minNodeVersion` if set, otherwise `lts/*`.\n   * @stability stable\n   */\n  readonly workflowNodeVersion?: string;\n  /**\n   * The git identity to use in workflows.\n   * @default - default GitHub Actions user\n   * @stability stable\n   */\n  readonly workflowGitIdentity?: github.GitIdentity;\n  /**\n   * Workflow steps to use in order to bootstrap this repo.\n   * @default \"yarn install --frozen-lockfile && yarn projen\"\n   * @stability stable\n   */\n  readonly workflowBootstrapSteps?: Array<github.workflows.JobStep>;\n  /**\n   * Automatically release to npm when new versions are introduced.\n   * @default false\n   * @stability stable\n   */\n  readonly releaseToNpm?: boolean;\n  /**\n   * Add release management to this project.\n   * @default - true (false for subprojects)\n   * @stability stable\n   */\n  readonly release?: boolean;\n  /**\n   * The contents of the pull request template.\n   * @default - default content\n   * @stability stable\n   */\n  readonly pullRequestTemplateContents?: Array<string>;\n  /**\n   * Include a GitHub pull request template.\n   * @default true\n   * @stability stable\n   */\n  readonly pullRequestTemplate?: boolean;\n  /**\n   * Version of projen to install.\n   * @default - Defaults to the latest version.\n   * @stability stable\n   */\n  readonly projenVersion?: string;\n  /**\n   * Options for .projenrc.js.\n   * @default - default options\n   * @stability stable\n   */\n  readonly projenrcJsOptions?: javascript.ProjenrcOptions;\n  /**\n   * Generate (once) .projenrc.js (in JavaScript). Set to `false` in order to disable .projenrc.js generation.\n   * @default - true if projenrcJson is false\n   * @stability stable\n   */\n  readonly projenrcJs?: boolean;\n  /**\n   * Indicates of \"projen\" should be installed as a devDependency.\n   * @default - true if not a subproject\n   * @stability stable\n   */\n  readonly projenDevDependency?: boolean;\n  /**\n   * Prettier options.\n   * @default - default options\n   * @stability stable\n   */\n  readonly prettierOptions?: javascript.PrettierOptions;\n  /**\n   * Setup prettier.\n   * @default false\n   * @stability stable\n   */\n  readonly prettier?: boolean;\n  /**\n   * Defines a `package` task that will produce an npm tarball under the artifacts directory (e.g. `dist`).\n   * @default true\n   * @stability stable\n   */\n  readonly package?: boolean;\n  /**\n   * Configuration options for .npmignore file.\n   * @stability stable\n   */\n  readonly npmIgnoreOptions?: IgnoreFileOptions;\n  /**\n   * Defines an .npmignore file. Normally this is only needed for libraries that are packaged as tarballs.\n   * @default true\n   * @stability stable\n   */\n  readonly npmignoreEnabled?: boolean;\n  /**\n   * Jest options.\n   * @default - default options\n   * @stability stable\n   */\n  readonly jestOptions?: javascript.JestOptions;\n  /**\n   * Setup jest unit tests.\n   * @default true\n   * @stability stable\n   */\n  readonly jest?: boolean;\n  /**\n   * Additional entries to .gitignore.\n   * @stability stable\n   */\n  readonly gitignore?: Array<string>;\n  /**\n   * Options for `UpgradeDependencies`.\n   * @default - default options\n   * @stability stable\n   */\n  readonly depsUpgradeOptions?: javascript.UpgradeDependenciesOptions;\n  /**\n   * Use tasks and github workflows to handle dependency upgrades.\n   * Cannot be used in conjunction with `dependabot`.\n   * @default true\n   * @stability stable\n   */\n  readonly depsUpgrade?: boolean;\n  /**\n   * Options for dependabot.\n   * @default - default options\n   * @stability stable\n   */\n  readonly dependabotOptions?: github.DependabotOptions;\n  /**\n   * Use dependabot to handle dependency upgrades.\n   * Cannot be used in conjunction with `depsUpgrade`.\n   * @default false\n   * @stability stable\n   */\n  readonly dependabot?: boolean;\n  /**\n   * The copyright years to put in the LICENSE file.\n   * @default - current year\n   * @stability stable\n   */\n  readonly copyrightPeriod?: string;\n  /**\n   * License copyright owner.\n   * @default - defaults to the value of authorName or \"\" if `authorName` is undefined.\n   * @stability stable\n   */\n  readonly copyrightOwner?: string;\n  /**\n   * Define the secret name for a specified https://codecov.io/ token.\n   * @default - OIDC auth is used\n   * @stability stable\n   */\n  readonly codeCovTokenSecret?: string;\n  /**\n   * Define a GitHub workflow step for sending code coverage metrics to https://codecov.io/ Uses codecov/codecov-action@v5 By default, OIDC auth is used. Alternatively a token can be provided via `codeCovTokenSecret`.\n   * @default false\n   * @stability stable\n   */\n  readonly codeCov?: boolean;\n  /**\n   * Configure which licenses should be deemed acceptable for use by dependencies.\n   * This setting will cause the build to fail, if any prohibited or not allowed licenses ares encountered.\n   * @default - no license checks are run during the build and all licenses will be accepted\n   * @stability stable\n   */\n  readonly checkLicenses?: javascript.LicenseCheckerOptions;\n  /**\n   * Options for `Bundler`.\n   * @stability stable\n   */\n  readonly bundlerOptions?: javascript.BundlerOptions;\n  /**\n   * Options for PR build workflow.\n   * @stability stable\n   */\n  readonly buildWorkflowOptions?: javascript.BuildWorkflowOptions;\n  /**\n   * Define a GitHub workflow for building PRs.\n   * @default - true if not a subproject\n   * @stability stable\n   */\n  readonly buildWorkflow?: boolean;\n  /**\n   * Biome options.\n   * @default - default options\n   * @stability stable\n   */\n  readonly biomeOptions?: javascript.BiomeOptions;\n  /**\n   * Setup Biome.\n   * @default false\n   * @stability stable\n   */\n  readonly biome?: boolean;\n  /**\n   * Automatically approve deps upgrade PRs, allowing them to be merged by mergify (if configued).\n   * Throw if set to true but `autoApproveOptions` are not defined.\n   * @default - true\n   * @stability stable\n   */\n  readonly autoApproveUpgrades?: boolean;\n  /**\n   * A directory which will contain build artifacts.\n   * @default \"dist\"\n   * @stability stable\n   */\n  readonly artifactsDirectory?: string;\n  /**\n   * The name of the main release branch.\n   * @default \"main\"\n   * @stability stable\n   */\n  readonly defaultReleaseBranch: string;\n  /**\n   * Github Runner Group selection options.\n   * @stability stable\n   * @description Defines a target Runner Group by name and/or labels\n   * @throws {Error} if both `runsOn` and `runsOnGroup` are specified\n   */\n  readonly workflowRunsOnGroup?: GroupRunnerOptions;\n  /**\n   * Github Runner selection labels.\n   * @default [\"ubuntu-latest\"]\n   * @stability stable\n   * @description Defines a target Runner by labels\n   * @throws {Error} if both `runsOn` and `runsOnGroup` are specified\n   */\n  readonly workflowRunsOn?: Array<string>;\n  /**\n   * Container image to use for GitHub workflows.\n   * @default - default image\n   * @stability stable\n   */\n  readonly workflowContainerImage?: string;\n  /**\n   * Custom configuration used when creating changelog with commit-and-tag-version package.\n   * Given values either append to default configuration or overwrite values in it.\n   * @default - standard configuration applicable for GitHub repositories\n   * @stability stable\n   */\n  readonly versionrcOptions?: Record<string, any>;\n  /**\n   * A set of workflow steps to execute in order to setup the workflow container.\n   * @stability stable\n   */\n  readonly releaseWorkflowSetupSteps?: Array<github.workflows.JobStep>;\n  /**\n   * The name of the default release workflow.\n   * @default \"release\"\n   * @stability stable\n   */\n  readonly releaseWorkflowName?: string;\n  /**\n   * Build environment variables for release workflows.\n   * @default {}\n   * @stability stable\n   */\n  readonly releaseWorkflowEnv?: Record<string, string>;\n  /**\n   * The release trigger to use.\n   * @default - Continuous releases (`ReleaseTrigger.continuous()`)\n   * @stability stable\n   */\n  readonly releaseTrigger?: release.ReleaseTrigger;\n  /**\n   * Automatically add the given prefix to release tags. Useful if you are releasing on multiple branches with overlapping version numbers.\n   * Note: this prefix is used to detect the latest tagged version\n   * when bumping, so if you change this on a project with an existing version\n   * history, you may need to manually tag your latest release\n   * with the new prefix.\n   * @default \"v\"\n   * @stability stable\n   */\n  readonly releaseTagPrefix?: string;\n  /**\n   * The label to apply to issues indicating publish failures.\n   * Only applies if `releaseFailureIssue` is true.\n   * @default \"failed-release\"\n   * @stability stable\n   */\n  readonly releaseFailureIssueLabel?: string;\n  /**\n   * Create a github issue on every failed publishing task.\n   * @default false\n   * @stability stable\n   */\n  readonly releaseFailureIssue?: boolean;\n  /**\n   * The GitHub Actions environment used for the release.\n   * This can be used to add an explicit approval step to the release\n   * or limit who can initiate a release through environment protection rules.\n   *\n   * When multiple artifacts are released, the environment can be overwritten\n   * on a per artifact basis.\n   * @default - no environment used, unless set at the artifact level\n   * @stability stable\n   */\n  readonly releaseEnvironment?: string;\n  /**\n   * Defines additional release branches.\n   * A workflow will be created for each\n   * release branch which will publish releases from commits in this branch.\n   * Each release branch _must_ be assigned a major version number which is used\n   * to enforce that versions published from that branch always use that major\n   * version. If multiple branches are used, the `majorVersion` field must also\n   * be provided for the default branch.\n   * @default - no additional branches are used for release. you can use\n`addBranch()` to add additional branches.\n   * @stability stable\n   */\n  readonly releaseBranches?: Record<string, release.BranchOptions>;\n  /**\n   * Find commits that should be considered releasable Used to decide if a release is required.\n   * @default ReleasableCommits.everyCommit()\n   * @stability stable\n   */\n  readonly releasableCommits?: ReleasableCommits;\n  /**\n   * Define publishing tasks that can be executed manually as well as workflows.\n   * Normally, publishing only happens within automated workflows. Enable this\n   * in order to create a publishing task for each publishing activity.\n   * @default false\n   * @stability stable\n   */\n  readonly publishTasks?: boolean;\n  /**\n   * Instead of actually publishing to package managers, just print the publishing command.\n   * @default false\n   * @stability stable\n   */\n  readonly publishDryRun?: boolean;\n  /**\n   * Bump versions from the default branch as pre-releases (e.g. \"beta\", \"alpha\", \"pre\").\n   * @default - normal semantic versions\n   * @stability stable\n   */\n  readonly prerelease?: string;\n  /**\n   * Steps to execute after build as part of the release workflow.\n   * @default []\n   * @stability stable\n   */\n  readonly postBuildSteps?: Array<github.workflows.JobStep>;\n  /**\n   * The npmDistTag to use when publishing from the default branch.\n   * To set the npm dist-tag for release branches, set the `npmDistTag` property\n   * for each branch.\n   * @default \"latest\"\n   * @stability stable\n   */\n  readonly npmDistTag?: string;\n  /**\n   * A shell command to control the next version to release.\n   * If present, this shell command will be run before the bump is executed, and\n   * it determines what version to release. It will be executed in the following\n   * environment:\n   *\n   * - Working directory: the project directory.\n   * - `$VERSION`: the current version. Looks like `1.2.3`.\n   * - `$LATEST_TAG`: the most recent tag. Looks like `prefix-v1.2.3`, or may be unset.\n   * - `$SUGGESTED_BUMP`: the suggested bump action based on commits. One of `major|minor|patch|none`.\n   *\n   * The command should print one of the following to `stdout`:\n   *\n   * - Nothing: the next version number will be determined based on commit history.\n   * - `x.y.z`: the next version number will be `x.y.z`.\n   * - `major|minor|patch`: the next version number will be the current version number\n   *   with the indicated component bumped.\n   *\n   * This setting cannot be specified together with `minMajorVersion`; the invoked\n   * script can be used to achieve the effects of `minMajorVersion`.\n   * @default - The next version will be determined based on the commit history and project settings.\n   * @stability stable\n   */\n  readonly nextVersionCommand?: string;\n  /**\n   * Minimal Major version to release.\n   * This can be useful to set to 1, as breaking changes before the 1.x major\n   * release are not incrementing the major version number.\n   *\n   * Can not be set together with `majorVersion`.\n   * @default - No minimum version is being enforced\n   * @stability stable\n   */\n  readonly minMajorVersion?: number;\n  /**\n   * Major version to release from the default branch.\n   * If this is specified, we bump the latest version of this major version line.\n   * If not specified, we bump the global latest version.\n   * @default - Major version is not enforced.\n   * @stability stable\n   */\n  readonly majorVersion?: number;\n  /**\n   * Version requirement of `publib` which is used to publish modules to npm.\n   * @default \"latest\"\n   * @stability stable\n   */\n  readonly jsiiReleaseVersion?: string;\n  /**\n   * The `commit-and-tag-version` compatible package used to bump the package version, as a dependency string.\n   * This can be any compatible package version, including the deprecated `standard-version@9`.\n   * @default - A recent version of \"commit-and-tag-version\"\n   * @stability stable\n   */\n  readonly bumpPackage?: string;\n  /**\n   * Options for Yarn Berry.\n   * @default - Yarn Berry v4 with all default options\n   * @stability stable\n   */\n  readonly yarnBerryOptions?: javascript.YarnBerryOptions;\n  /**\n   * Package's Stability.\n   * @stability stable\n   */\n  readonly stability?: string;\n  /**\n   * Options for privately hosted scoped packages.\n   * @default - fetch all scoped packages from the public npm registry\n   * @stability stable\n   */\n  readonly scopedPackagesOptions?: Array<javascript.ScopedPackagesOptions>;\n  /**\n   * If the package.json for your package is not in the root directory (for example if it is part of a monorepo), you can specify the directory in which it lives.\n   * @stability stable\n   */\n  readonly repositoryDirectory?: string;\n  /**\n   * The repository is the location where the actual code for your package lives.\n   * See https://classic.yarnpkg.com/en/docs/package-json/#toc-repository\n   * @stability stable\n   */\n  readonly repository?: string;\n  /**\n   * The version of PNPM to use if using PNPM as a package manager.\n   * @default \"9\"\n   * @stability stable\n   */\n  readonly pnpmVersion?: string;\n  /**\n   * Peer dependencies for this module.\n   * Dependencies listed here are required to\n   * be installed (and satisfied) by the _consumer_ of this library. Using peer\n   * dependencies allows you to ensure that only a single module of a certain\n   * library exists in the `node_modules` tree of your consumers.\n   *\n   * Note that prior to npm@7, peer dependencies are _not_ automatically\n   * installed, which means that adding peer dependencies to a library will be a\n   * breaking change for your customers.\n   *\n   * Unless `peerDependencyOptions.pinnedDevDependency` is disabled (it is\n   * enabled by default), projen will automatically add a dev dependency with a\n   * pinned version for each peer dependency. This will ensure that you build &\n   * test your module against the lowest peer version required.\n   * @default []\n   * @stability stable\n   */\n  readonly peerDeps?: Array<string>;\n  /**\n   * Options for `peerDeps`.\n   * @stability stable\n   */\n  readonly peerDependencyOptions?: javascript.PeerDependencyOptions;\n  /**\n   * The \"name\" in package.json.\n   * @default - defaults to project name\n   * @stability stable\n   * @featured true\n   */\n  readonly packageName?: string;\n  /**\n   * The Node Package Manager used to execute scripts.\n   * @default NodePackageManager.YARN_CLASSIC\n   * @stability stable\n   */\n  readonly packageManager?: javascript.NodePackageManager;\n  /**\n   * Use trusted publishing for publishing to npmjs.com Needs to be pre-configured on npm.js to work.\n   * @default - false\n   * @stability stable\n   */\n  readonly npmTrustedPublishing?: boolean;\n  /**\n   * GitHub secret which contains the NPM token to use when publishing packages.\n   * @default \"NPM_TOKEN\"\n   * @stability stable\n   */\n  readonly npmTokenSecret?: string;\n  /**\n   * The base URL of the npm package registry.\n   * Must be a URL (e.g. start with \"https://\" or \"http://\")\n   * @default \"https://registry.npmjs.org\"\n   * @stability stable\n   */\n  readonly npmRegistryUrl?: string;\n  /**\n   * Should provenance statements be generated when the package is published.\n   * A supported package manager is required to publish a package with npm provenance statements and\n   * you will need to use a supported CI/CD provider.\n   *\n   * Note that the projen `Release` and `Publisher` components are using `publib` to publish packages,\n   * which is using npm internally and supports provenance statements independently of the package manager used.\n   * @default - true for public packages, false otherwise\n   * @stability stable\n   */\n  readonly npmProvenance?: boolean;\n  /**\n   * Access level of the npm package.\n   * @default - for scoped packages (e.g. `foo@bar`), the default is\n`NpmAccess.RESTRICTED`, for non-scoped packages, the default is\n`NpmAccess.PUBLIC`.\n   * @stability stable\n   */\n  readonly npmAccess?: javascript.NpmAccess;\n  /**\n   * The minimum node version required by this package to function. Most projects should not use this option.\n   * The value indicates that the package is incompatible with any older versions of node.\n   * This requirement is enforced via the engines field.\n   *\n   * You will normally not need to set this option, even if your package is incompatible with EOL versions of node.\n   * Consider this option only if your package depends on a specific feature, that is not available in other LTS versions.\n   * Setting this option has very high impact on the consumers of your package,\n   * as package managers will actively prevent usage with node versions you have marked as incompatible.\n   *\n   * To change the node version of your CI/CD workflows, use `workflowNodeVersion`.\n   * @default - no minimum version is enforced\n   * @stability stable\n   */\n  readonly minNodeVersion?: string;\n  /**\n   * The maximum node version supported by this package. Most projects should not use this option.\n   * The value indicates that the package is incompatible with any newer versions of node.\n   * This requirement is enforced via the engines field.\n   *\n   * You will normally not need to set this option.\n   * Consider this option only if your package is known to not function with newer versions of node.\n   * @default - no maximum version is enforced\n   * @stability stable\n   */\n  readonly maxNodeVersion?: string;\n  /**\n   * Indicates if a license should be added.\n   * @default true\n   * @stability stable\n   */\n  readonly licensed?: boolean;\n  /**\n   * License's SPDX identifier.\n   * See https://github.com/projen/projen/tree/main/license-text for a list of supported licenses.\n   * Use the `licensed` option if you want to no license to be specified.\n   * @default \"Apache-2.0\"\n   * @stability stable\n   */\n  readonly license?: string;\n  /**\n   * Keywords to include in `package.json`.\n   * @stability stable\n   */\n  readonly keywords?: Array<string>;\n  /**\n   * Package's Homepage / Website.\n   * @stability stable\n   */\n  readonly homepage?: string;\n  /**\n   * Module entrypoint (`main` in `package.json`).\n   * Set to an empty string to not include `main` in your package.json\n   * @default \"lib/index.js\"\n   * @stability stable\n   */\n  readonly entrypoint?: string;\n  /**\n   * Build dependencies for this module.\n   * These dependencies will only be\n   * available in your build environment but will not be fetched when this\n   * module is consumed.\n   *\n   * The recommendation is to only specify the module name here (e.g.\n   * `express`). This will behave similar to `yarn add` or `npm install` in the\n   * sense that it will add the module as a dependency to your `package.json`\n   * file with the latest version (`^`). You can specify semver requirements in\n   * the same syntax passed to `npm i` or `yarn add` (e.g. `express@^2`) and\n   * this will be what you `package.json` will eventually include.\n   * @default []\n   * @stability stable\n   * @featured true\n   */\n  readonly devDeps?: Array<string>;\n  /**\n   * The description is just a string that helps people understand the purpose of the package.\n   * It can be used when searching for packages in a package manager as well.\n   * See https://classic.yarnpkg.com/en/docs/package-json/#toc-description\n   * @stability stable\n   * @featured true\n   */\n  readonly description?: string;\n  /**\n   * Runtime dependencies of this module.\n   * The recommendation is to only specify the module name here (e.g.\n   * `express`). This will behave similar to `yarn add` or `npm install` in the\n   * sense that it will add the module as a dependency to your `package.json`\n   * file with the latest version (`^`). You can specify semver requirements in\n   * the same syntax passed to `npm i` or `yarn add` (e.g. `express@^2`) and\n   * this will be what you `package.json` will eventually include.\n   * @default []\n   * @stability stable\n   * @featured true\n   */\n  readonly deps?: Array<string>;\n  /**\n   * Options for npm packages using AWS CodeArtifact.\n   * This is required if publishing packages to, or installing scoped packages from AWS CodeArtifact\n   * @default - undefined\n   * @stability stable\n   */\n  readonly codeArtifactOptions?: javascript.CodeArtifactOptions;\n  /**\n   * The version of Bun to use if using Bun as a package manager.\n   * @default \"latest\"\n   * @stability stable\n   */\n  readonly bunVersion?: string;\n  /**\n   * List of dependencies to bundle into this module.\n   * These modules will be\n   * added both to the `dependencies` section and `bundledDependencies` section of\n   * your `package.json`.\n   *\n   * The recommendation is to only specify the module name here (e.g.\n   * `express`). This will behave similar to `yarn add` or `npm install` in the\n   * sense that it will add the module as a dependency to your `package.json`\n   * file with the latest version (`^`). You can specify semver requirements in\n   * the same syntax passed to `npm i` or `yarn add` (e.g. `express@^2`) and\n   * this will be what you `package.json` will eventually include.\n   * @stability stable\n   */\n  readonly bundledDeps?: Array<string>;\n  /**\n   * The url to your project's issue tracker.\n   * @stability stable\n   */\n  readonly bugsUrl?: string;\n  /**\n   * The email address to which issues should be reported.\n   * @stability stable\n   */\n  readonly bugsEmail?: string;\n  /**\n   * Binary programs vended with your module.\n   * You can use this option to add/customize how binaries are represented in\n   * your `package.json`, but unless `autoDetectBin` is `false`, every\n   * executable file under `bin` will automatically be added to this section.\n   * @stability stable\n   */\n  readonly bin?: Record<string, string>;\n  /**\n   * Automatically add all executables under the `bin` directory to your `package.json` file under the `bin` section.\n   * @default true\n   * @stability stable\n   */\n  readonly autoDetectBin?: boolean;\n  /**\n   * Author's URL / Website.\n   * @stability stable\n   */\n  readonly authorUrl?: string;\n  /**\n   * Is the author an organization.\n   * @stability stable\n   */\n  readonly authorOrganization?: boolean;\n  /**\n   * Author's name.\n   * @stability stable\n   */\n  readonly authorName?: string;\n  /**\n   * Author's e-mail.\n   * @stability stable\n   */\n  readonly authorEmail?: string;\n  /**\n   * Allow the project to include `peerDependencies` and `bundledDependencies`.\n   * This is normally only allowed for libraries. For apps, there's no meaning\n   * for specifying these.\n   * @default true\n   * @stability stable\n   */\n  readonly allowLibraryDependencies?: boolean;\n  /**\n   * Enable VSCode integration.\n   * Enabled by default for root projects. Disabled for non-root projects.\n   * @default true\n   * @stability stable\n   */\n  readonly vscode?: boolean;\n  /**\n   * Auto-close stale issues and pull requests.\n   * To disable set `stale` to `false`.\n   * @default - see defaults in `StaleOptions`\n   * @stability stable\n   */\n  readonly staleOptions?: github.StaleOptions;\n  /**\n   * Auto-close of stale issues and pull request.\n   * See `staleOptions` for options.\n   * @default false\n   * @stability stable\n   */\n  readonly stale?: boolean;\n  /**\n   * The README setup.\n   * @default - { filename: 'README.md', contents: '# replace this' }\n   * @stability stable\n   */\n  readonly readme?: SampleReadmeProps;\n  /**\n   * Choose a method of providing GitHub API access for projen workflows.\n   * @default - use a personal access token named PROJEN_GITHUB_TOKEN\n   * @stability stable\n   */\n  readonly projenCredentials?: github.GithubCredentials;\n  /**\n   * Add a Gitpod development environment.\n   * @default false\n   * @stability stable\n   */\n  readonly gitpod?: boolean;\n  /**\n   * Options for GitHub integration.\n   * @default - see GitHubOptions\n   * @stability stable\n   */\n  readonly githubOptions?: github.GitHubOptions;\n  /**\n   * Enable GitHub integration.\n   * Enabled by default for root projects. Disabled for non-root projects.\n   * @default true\n   * @stability stable\n   */\n  readonly github?: boolean;\n  /**\n   * Add a VSCode development environment (used for GitHub Codespaces).\n   * @default false\n   * @stability stable\n   */\n  readonly devContainer?: boolean;\n  /**\n   * Add a `clobber` task which resets the repo to origin.\n   * @default - true, but false for subprojects\n   * @stability stable\n   */\n  readonly clobber?: boolean;\n  /**\n   * Configure options for automatic merging on GitHub.\n   * Has no effect if\n   * `github.mergify` or `autoMerge` is set to false.\n   * @default - see defaults in `AutoMergeOptions`\n   * @stability stable\n   */\n  readonly autoMergeOptions?: github.AutoMergeOptions;\n  /**\n   * Enable automatic merging on GitHub.\n   * Has no effect if `github.mergify`\n   * is set to false.\n   * @default true\n   * @stability stable\n   */\n  readonly autoMerge?: boolean;\n  /**\n   * Enable and configure the 'auto approve' workflow.\n   * @default - auto approve is disabled\n   * @stability stable\n   */\n  readonly autoApproveOptions?: github.AutoApproveOptions;\n  /**\n   * Options for renovatebot.\n   * @default - default options\n   * @stability stable\n   */\n  readonly renovatebotOptions?: RenovatebotOptions;\n  /**\n   * Use renovatebot to handle dependency upgrades.\n   * @default false\n   * @stability stable\n   */\n  readonly renovatebot?: boolean;\n  /**\n   * Options for .projenrc.json.\n   * @default - default options\n   * @stability stable\n   */\n  readonly projenrcJsonOptions?: ProjenrcJsonOptions;\n  /**\n   * Generate (once) .projenrc.json (in JSON). Set to `false` in order to disable .projenrc.json generation.\n   * @default false\n   * @stability stable\n   */\n  readonly projenrcJson?: boolean;\n  /**\n   * The shell command to use in order to run the projen CLI.\n   * Can be used to customize in special environments.\n   * @default \"npx projen\"\n   * @stability stable\n   */\n  readonly projenCommand?: string;\n  /**\n   * The parent project, if this project is part of a bigger project.\n   * @stability stable\n   */\n  readonly parent?: Project;\n  /**\n   * The root directory of the project.\n   * Relative to this directory, all files are synthesized.\n   *\n   * If this project has a parent, this directory is relative to the parent\n   * directory and it cannot be the same as the parent or any of it's other\n   * subprojects.\n   * @default \".\"\n   * @stability stable\n   */\n  readonly outdir?: string;\n  /**\n   * Configure logging options such as verbosity.\n   * @default {}\n   * @stability stable\n   */\n  readonly logging?: LoggerOptions;\n  /**\n   * Configuration options for git.\n   * @stability stable\n   */\n  readonly gitOptions?: GitOptions;\n  /**\n   * Configuration options for .gitignore file.\n   * @stability stable\n   */\n  readonly gitIgnoreOptions?: IgnoreFileOptions;\n  /**\n   * Whether to commit the managed files by default.\n   * @default true\n   * @stability stable\n   */\n  readonly commitGenerated?: boolean;\n  /**\n   * This is the name of your project.\n   * @default $BASEDIR\n   * @stability stable\n   * @featured true\n   */\n  readonly name: string;\n}\n"]}

package/lib/construct-project.js

@@ -11,5 +11,5 @@ class ConstructProject extends projen_1.awscdk.AwsCdkConstructLibrary {
 }
 exports.ConstructProject = ConstructProject;
 _a = JSII_RTTI_SYMBOL_1;
-ConstructProject[_a] = { fqn: "mrpj.ConstructProject", version: "0.2.4" };
+ConstructProject[_a] = { fqn: "mrpj.ConstructProject", version: "0.2.6" };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RydWN0LXByb2plY3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uc3RydWN0LXByb2plY3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxtQ0FBZ0M7QUFFaEM7O0dBRUc7QUFDSCxNQUFhLGdCQUFpQixTQUFRLGVBQU0sQ0FBQyxzQkFBc0I7O0FBQW5FLDRDQUNDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYXdzY2RrIH0gZnJvbSAncHJvamVuJztcblxuLyoqXG4gKiBAcGppZCBjb25zdHJ1Y3RcbiAqL1xuZXhwb3J0IGNsYXNzIENvbnN0cnVjdFByb2plY3QgZXh0ZW5kcyBhd3NjZGsuQXdzQ2RrQ29uc3RydWN0TGlicmFyeSB7XG59XG4iXX0=

package/lib/features/automation.d.ts

@@ -1,10 +1,13 @@
+import type { Project } from 'projen';
 import type { RepoInfoTrait } from './package-info';
-import type { OptionsMiddleware } from '../utils';
+import type { FeatureMiddleware, OptionsMiddleware } from '../utils';
 export interface AutomationOptionsTrait extends RepoInfoTrait {
     readonly automationAppName?: string;
+    readonly automationEnvironment?: string;
     readonly ownerCanSelfApprovePRs?: boolean;
     readonly allowedCommitTypes?: string[];
     readonly releasableCommitTypes?: string[];
 }
 export declare const optionsMiddleware: OptionsMiddleware<AutomationOptionsTrait>;
 export declare const ALLOWED_COMMIT_TYPES_DEFAULT: string[];
+export declare const protectAutomationCredentials: FeatureMiddleware<Project, AutomationOptionsTrait>;

package/lib/features/automation.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALLOWED_COMMIT_TYPES_DEFAULT = exports.optionsMiddleware = void 0;
+exports.protectAutomationCredentials = exports.ALLOWED_COMMIT_TYPES_DEFAULT = exports.optionsMiddleware = void 0;
 const projen_1 = require("projen");
 const package_info_1 = require("./package-info");
 const release_1 = require("./release");
 const utils_1 = require("../utils");
 const optionsMiddleware = (options) => (0, utils_1.deepMerge)({
+    automationEnvironment: options.automationEnvironment ?? 'automation',
     githubOptions: {
         projenCredentials: (0, utils_1.ifSet)(options.automationAppName, projen_1.github.GithubCredentials.fromApp()),
         pullRequestLintOptions: {
@@ -27,4 +28,13 @@ const optionsMiddleware = (options) => (0, utils_1.deepMerge)({
 }, options);
 exports.optionsMiddleware = optionsMiddleware;
 exports.ALLOWED_COMMIT_TYPES_DEFAULT = ['feat', 'fix', 'chore', 'revert', 'docs', 'ci'];
-//# sourceMappingURL=data:application/json;base64,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
+const protectAutomationCredentials = (project, options) => {
+    if (options.automationEnvironment) {
+        for (const wf of project.components.filter(c => c instanceof projen_1.javascript.UpgradeDependencies).flatMap(c => c.workflows)) {
+            wf.file?.patch(projen_1.JsonPatch.add('/jobs/pr/environment', options.automationEnvironment));
+        }
+    }
+    return project;
+};
+exports.protectAutomationCredentials = protectAutomationCredentials;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/features/index.d.ts

@@ -7,3 +7,5 @@ export { featureMiddleware as logo } from './logo';
 export { featureMiddleware as nodeVersion } from './node-version';
 export { makeMiddleware as packageInfo } from './package-info';
 export { optionsMiddleware as release } from './release';
+export { trustedPublisherFix as trustedPublisherFix } from './release';
+export { featureMiddleware as selfMutationOnForks } from './self-mutation';

package/lib/features/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.release = exports.packageInfo = exports.nodeVersion = exports.logo = exports.defaultOptions = exports.forceOptions = exports.eslint = exports.preventSelfDependency = exports.ensureDependencies = exports.dependencies = exports.automation = void 0;
+exports.selfMutationOnForks = exports.trustedPublisherFix = exports.release = exports.packageInfo = exports.nodeVersion = exports.logo = exports.defaultOptions = exports.forceOptions = exports.eslint = exports.preventSelfDependency = exports.ensureDependencies = exports.dependencies = exports.automation = void 0;
 var automation_1 = require("./automation");
 Object.defineProperty(exports, "automation", { enumerable: true, get: function () { return automation_1.optionsMiddleware; } });
 var dependencies_1 = require("./dependencies");
@@ -21,4 +21,8 @@ var package_info_1 = require("./package-info");
 Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return package_info_1.makeMiddleware; } });
 var release_1 = require("./release");
 Object.defineProperty(exports, "release", { enumerable: true, get: function () { return release_1.optionsMiddleware; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmVhdHVyZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsMkNBQStEO0FBQXRELHdHQUFBLGlCQUFpQixPQUFjO0FBQ3hDLCtDQUEyRztBQUFsRyw0R0FBQSxjQUFjLE9BQWdCO0FBQUUsa0hBQUEsa0JBQWtCLE9BQUE7QUFBRSxxSEFBQSxxQkFBcUIsT0FBQTtBQUNsRixtQ0FBdUQ7QUFBOUMsZ0dBQUEsaUJBQWlCLE9BQVU7QUFDcEMsaURBQWlFO0FBQXhELDZHQUFBLGNBQWMsT0FBZ0I7QUFDdkMscURBQXFFO0FBQTVELGlIQUFBLGNBQWMsT0FBa0I7QUFDekMsK0JBQW1EO0FBQTFDLDRGQUFBLGlCQUFpQixPQUFRO0FBQ2xDLCtDQUFrRTtBQUF6RCwyR0FBQSxpQkFBaUIsT0FBZTtBQUN6QywrQ0FBK0Q7QUFBdEQsMkdBQUEsY0FBYyxPQUFlO0FBQ3RDLHFDQUF5RDtBQUFoRCxrR0FBQSxpQkFBaUIsT0FBVyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IG9wdGlvbnNNaWRkbGV3YXJlIGFzIGF1dG9tYXRpb24gfSBmcm9tICcuL2F1dG9tYXRpb24nO1xuZXhwb3J0IHsgbWFrZU1pZGRsZXdhcmUgYXMgZGVwZW5kZW5jaWVzLCBlbnN1cmVEZXBlbmRlbmNpZXMsIHByZXZlbnRTZWxmRGVwZW5kZW5jeSB9IGZyb20gJy4vZGVwZW5kZW5jaWVzJztcbmV4cG9ydCB7IGZlYXR1cmVNaWRkbGV3YXJlIGFzIGVzbGludCB9IGZyb20gJy4vZXNsaW50JztcbmV4cG9ydCB7IG1ha2VNaWRkbGV3YXJlIGFzIGZvcmNlT3B0aW9ucyB9IGZyb20gJy4vZm9yY2Utb3B0aW9ucyc7XG5leHBvcnQgeyBtYWtlTWlkZGxld2FyZSBhcyBkZWZhdWx0T3B0aW9ucyB9IGZyb20gJy4vZGVmYXVsdC1vcHRpb25zJztcbmV4cG9ydCB7IGZlYXR1cmVNaWRkbGV3YXJlIGFzIGxvZ28gfSBmcm9tICcuL2xvZ28nO1xuZXhwb3J0IHsgZmVhdHVyZU1pZGRsZXdhcmUgYXMgbm9kZVZlcnNpb24gfSBmcm9tICcuL25vZGUtdmVyc2lvbic7XG5leHBvcnQgeyBtYWtlTWlkZGxld2FyZSBhcyBwYWNrYWdlSW5mbyB9IGZyb20gJy4vcGFja2FnZS1pbmZvJztcbmV4cG9ydCB7IG9wdGlvbnNNaWRkbGV3YXJlIGFzIHJlbGVhc2UgfSBmcm9tICcuL3JlbGVhc2UnO1xuIl19
+var release_2 = require("./release");
+Object.defineProperty(exports, "trustedPublisherFix", { enumerable: true, get: function () { return release_2.trustedPublisherFix; } });
+var self_mutation_1 = require("./self-mutation");
+Object.defineProperty(exports, "selfMutationOnForks", { enumerable: true, get: function () { return self_mutation_1.featureMiddleware; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmVhdHVyZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsMkNBQStEO0FBQXRELHdHQUFBLGlCQUFpQixPQUFjO0FBQ3hDLCtDQUEyRztBQUFsRyw0R0FBQSxjQUFjLE9BQWdCO0FBQUUsa0hBQUEsa0JBQWtCLE9BQUE7QUFBRSxxSEFBQSxxQkFBcUIsT0FBQTtBQUNsRixtQ0FBdUQ7QUFBOUMsZ0dBQUEsaUJBQWlCLE9BQVU7QUFDcEMsaURBQWlFO0FBQXhELDZHQUFBLGNBQWMsT0FBZ0I7QUFDdkMscURBQXFFO0FBQTVELGlIQUFBLGNBQWMsT0FBa0I7QUFDekMsK0JBQW1EO0FBQTFDLDRGQUFBLGlCQUFpQixPQUFRO0FBQ2xDLCtDQUFrRTtBQUF6RCwyR0FBQSxpQkFBaUIsT0FBZTtBQUN6QywrQ0FBK0Q7QUFBdEQsMkdBQUEsY0FBYyxPQUFlO0FBQ3RDLHFDQUF5RDtBQUFoRCxrR0FBQSxpQkFBaUIsT0FBVztBQUNyQyxxQ0FBdUU7QUFBOUQsOEdBQUEsbUJBQW1CLE9BQXVCO0FBQ25ELGlEQUEyRTtBQUFsRSxvSEFBQSxpQkFBaUIsT0FBdUIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBvcHRpb25zTWlkZGxld2FyZSBhcyBhdXRvbWF0aW9uIH0gZnJvbSAnLi9hdXRvbWF0aW9uJztcbmV4cG9ydCB7IG1ha2VNaWRkbGV3YXJlIGFzIGRlcGVuZGVuY2llcywgZW5zdXJlRGVwZW5kZW5jaWVzLCBwcmV2ZW50U2VsZkRlcGVuZGVuY3kgfSBmcm9tICcuL2RlcGVuZGVuY2llcyc7XG5leHBvcnQgeyBmZWF0dXJlTWlkZGxld2FyZSBhcyBlc2xpbnQgfSBmcm9tICcuL2VzbGludCc7XG5leHBvcnQgeyBtYWtlTWlkZGxld2FyZSBhcyBmb3JjZU9wdGlvbnMgfSBmcm9tICcuL2ZvcmNlLW9wdGlvbnMnO1xuZXhwb3J0IHsgbWFrZU1pZGRsZXdhcmUgYXMgZGVmYXVsdE9wdGlvbnMgfSBmcm9tICcuL2RlZmF1bHQtb3B0aW9ucyc7XG5leHBvcnQgeyBmZWF0dXJlTWlkZGxld2FyZSBhcyBsb2dvIH0gZnJvbSAnLi9sb2dvJztcbmV4cG9ydCB7IGZlYXR1cmVNaWRkbGV3YXJlIGFzIG5vZGVWZXJzaW9uIH0gZnJvbSAnLi9ub2RlLXZlcnNpb24nO1xuZXhwb3J0IHsgbWFrZU1pZGRsZXdhcmUgYXMgcGFja2FnZUluZm8gfSBmcm9tICcuL3BhY2thZ2UtaW5mbyc7XG5leHBvcnQgeyBvcHRpb25zTWlkZGxld2FyZSBhcyByZWxlYXNlIH0gZnJvbSAnLi9yZWxlYXNlJztcbmV4cG9ydCB7IHRydXN0ZWRQdWJsaXNoZXJGaXggYXMgdHJ1c3RlZFB1Ymxpc2hlckZpeCB9IGZyb20gJy4vcmVsZWFzZSc7XG5leHBvcnQgeyBmZWF0dXJlTWlkZGxld2FyZSBhcyBzZWxmTXV0YXRpb25PbkZvcmtzIH0gZnJvbSAnLi9zZWxmLW11dGF0aW9uJztcbiJdfQ==

package/lib/features/release.d.ts

@@ -1,9 +1,13 @@
+import type { Project } from 'projen';
 import type { TypeScriptProjectOptions } from '../typescript-project-options';
-import type { OptionsMiddleware } from '../utils';
+import type { FeatureMiddleware, OptionsMiddleware } from '../utils';
 export interface ReleaseOptionsTrait {
     readonly release?: TypeScriptProjectOptions['release'];
+    readonly npmTrustedPublishing?: TypeScriptProjectOptions['npmTrustedPublishing'];
+    readonly releaseEnvironment?: TypeScriptProjectOptions['releaseEnvironment'];
     readonly projenrcTsOptions?: TypeScriptProjectOptions['projenrcTsOptions'];
     readonly releasableCommitTypes?: string[];
 }
 export declare const optionsMiddleware: OptionsMiddleware<ReleaseOptionsTrait>;
 export declare const RELEASABLE_COMMIT_TYPES_DEFAULT: string[];
+export declare const trustedPublisherFix: FeatureMiddleware<Project, ReleaseOptionsTrait>;