projen 0.78.9 → 0.78.10

package/lib/github/workflow-steps.d.ts

@@ -1,5 +1,5 @@
 import { GitIdentity } from "./task-workflow";
-import { JobStep } from "./workflows-model";
+import { JobStepConfiguration, JobStep } from "./workflows-model";
 /**
  * A collection of very commonly used, individual, GitHub Workflow Job steps.
  */
@@ -17,23 +17,10 @@ export declare class WorkflowSteps {
      * @returns Job steps
      */
     static setupGitIdentity(options: SetupGitIdentityOptions): JobStep;
-    private static _buildCommonWorkflowSteps;
+    static uploadArtifact(options: UploadArtifactOptions): JobStep;
+    private static buildJobStepConfig;
 }
-export interface CommonWorkflowStepOptions {
-    /**
-     * A unique identifier for the step.
-     */
-    readonly id?: string;
-    /**
-     * A condition to determine whether to run this step.
-     */
-    readonly if?: string;
-    /**
-     * The name of the step.
-     */
-    readonly name?: string;
-}
-export interface CheckoutOptions extends CommonWorkflowStepOptions {
+export interface CheckoutOptions extends JobStepConfiguration {
     /**
      * Options for `checkout`.
      */
@@ -74,9 +61,55 @@ export interface CheckoutWith {
      */
     readonly token?: string;
 }
-export interface SetupGitIdentityOptions extends CommonWorkflowStepOptions {
+export interface SetupGitIdentityOptions extends JobStepConfiguration {
     /**
      * The identity to use.
      */
     readonly gitIdentity: GitIdentity;
 }
+export interface UploadArtifactWith {
+    /**
+     * Name of the artifact to upload.
+     *
+     * @default "artifact"
+     */
+    readonly name?: string;
+    /**
+     * A file, directory or wildcard pattern that describes what to upload
+     */
+    readonly path: string;
+    /**
+     * The desired behavior if no files are found using the provided path.
+     * Available Options:
+     *   warn: Output a warning but do not fail the action
+     *   error: Fail the action with an error message
+     *   ignore: Do not output any warnings or errors, the action does not fail
+     *
+     * @default "warn"
+     */
+    readonly ifNoFilesFound?: "error" | "warn" | "ignore";
+    /**
+     * Duration after which artifact will expire in days. 0 means using default repository retention.
+     *
+     * Minimum 1 day.
+     * Maximum 90 days unless changed from the repository settings page.
+     *
+     * @default - The default repository retention
+     */
+    readonly retentionDays?: number;
+    /**
+     * The level of compression for Zlib to be applied to the artifact archive.
+     *
+     * The value can range from 0 to 9.
+     * For large files that are not easily compressed, a value of 0 is recommended for significantly faster uploads.
+     *
+     * @default 6
+     */
+    readonly compressionLevel?: number;
+}
+export interface UploadArtifactOptions extends JobStepConfiguration {
+    /**
+     * Options for `upload-artifact`.
+     */
+    readonly with: UploadArtifactWith;
+}

package/lib/github/workflow-steps.js

@@ -23,7 +23,7 @@ class WorkflowSteps {
             ...(options?.with?.lfs ? { lfs: true } : {}),
         });
         return {
-            ...this._buildCommonWorkflowSteps({
+            ...this.buildJobStepConfig({
                 ...options,
                 name: options.name ?? "Checkout",
             }),
@@ -38,7 +38,7 @@ class WorkflowSteps {
      */
     static setupGitIdentity(options) {
         return {
-            ...this._buildCommonWorkflowSteps({
+            ...this.buildJobStepConfig({
                 ...options,
                 name: options.name ?? "Set git identity",
             }),
@@ -48,15 +48,36 @@ class WorkflowSteps {
             ].join("\n"),
         };
     }
-    static _buildCommonWorkflowSteps(options) {
+    static uploadArtifact(options) {
+        const uploadArtifactWith = (0, object_1.removeNullOrUndefinedProperties)({
+            name: options?.with?.name,
+            path: options?.with?.path,
+            "if-no-files-found": options?.with?.ifNoFilesFound,
+            "retention-days": options?.with?.retentionDays,
+            "compression-level": options?.with?.compressionLevel,
+        });
+        return {
+            ...this.buildJobStepConfig({
+                ...options,
+                name: options.name ?? "Upload artifact",
+            }),
+            uses: "actions/upload-artifact@v3",
+            with: uploadArtifactWith,
+        };
+    }
+    static buildJobStepConfig(options) {
         return {
+            continueOnError: options?.continueOnError,
+            env: options?.env,
             id: options?.id,
             if: options?.if,
             name: options?.name,
+            timeoutMinutes: options?.timeoutMinutes,
+            workingDirectory: options?.workingDirectory,
         };
     }
 }
 exports.WorkflowSteps = WorkflowSteps;
 _a = JSII_RTTI_SYMBOL_1;
-WorkflowSteps[_a] = { fqn: "projen.github.WorkflowSteps", version: "0.78.9" };
-//# sourceMappingURL=data:application/json;base64,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
+WorkflowSteps[_a] = { fqn: "projen.github.WorkflowSteps", version: "0.78.10" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow-steps.js","sourceRoot":"","sources":["../../src/github/workflow-steps.ts"],"names":[],"mappings":";;;;;AAEA,2CAAiE;AAEjE;;GAEG;AACH,MAAa,aAAa;IACxB;;;;;OAKG;IACI,MAAM,CAAC,QAAQ,CAAC,UAA2B,EAAE;QAClD,MAAM,YAAY,GAAG,IAAA,wCAA+B,EAAC;YACnD,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU;YACxC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK;YAC3B,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG;YACvB,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU;YACrC,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC7C,CAAC,CAAC;QAEH,OAAO;YACL,GAAG,IAAI,CAAC,kBAAkB,CAAC;gBACzB,GAAG,OAAO;gBACV,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,UAAU;aACjC,CAAC;YACF,IAAI,EAAE,qBAAqB;YAC3B,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS;SACtE,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,gBAAgB,CAAC,OAAgC;QAC7D,OAAO;YACL,GAAG,IAAI,CAAC,kBAAkB,CAAC;gBACzB,GAAG,OAAO;gBACV,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,kBAAkB;aACzC,CAAC;YACF,GAAG,EAAE;gBACH,yBAAyB,OAAO,CAAC,WAAW,CAAC,IAAI,GAAG;gBACpD,0BAA0B,OAAO,CAAC,WAAW,CAAC,KAAK,GAAG;aACvD,CAAC,IAAI,CAAC,IAAI,CAAC;SACb,CAAC;IACJ,CAAC;IAEM,MAAM,CAAC,cAAc,CAAC,OAA8B;QACzD,MAAM,kBAAkB,GACtB,IAAA,wCAA+B,EAAC;YAC9B,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI;YACzB,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI;YACzB,mBAAmB,EAAE,OAAO,EAAE,IAAI,EAAE,cAAc;YAClD,gBAAgB,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa;YAC9C,mBAAmB,EAAE,OAAO,EAAE,IAAI,EAAE,gBAAgB;SACrD,CAAC,CAAC;QAEL,OAAO;YACL,GAAG,IAAI,CAAC,kBAAkB,CAAC;gBACzB,GAAG,OAAO;gBACV,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,iBAAiB;aACxC,CAAC;YACF,IAAI,EAAE,4BAA4B;YAClC,IAAI,EAAE,kBAAkB;SACzB,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,kBAAkB,CAC/B,OAA6B;QAE7B,OAAO;YACL,eAAe,EAAE,OAAO,EAAE,eAAe;YACzC,GAAG,EAAE,OAAO,EAAE,GAAG;YACjB,EAAE,EAAE,OAAO,EAAE,EAAE;YACf,EAAE,EAAE,OAAO,EAAE,EAAE;YACf,IAAI,EAAE,OAAO,EAAE,IAAI;YACnB,cAAc,EAAE,OAAO,EAAE,cAAc;YACvC,gBAAgB,EAAE,OAAO,EAAE,gBAAgB;SAC5C,CAAC;IACJ,CAAC;;AA5EH,sCA6EC","sourcesContent":["import { GitIdentity } from \"./task-workflow\";\nimport { JobStepConfiguration, JobStep } from \"./workflows-model\";\nimport { removeNullOrUndefinedProperties } from \"../util/object\";\n\n/**\n * A collection of very commonly used, individual, GitHub Workflow Job steps.\n */\nexport class WorkflowSteps {\n  /**\n   * Checks out a repository.\n   *\n   * @param options Options\n   * @returns Job steps\n   */\n  public static checkout(options: CheckoutOptions = {}): JobStep {\n    const checkoutWith = removeNullOrUndefinedProperties({\n      \"fetch-depth\": options?.with?.fetchDepth,\n      token: options?.with?.token,\n      ref: options?.with?.ref,\n      repository: options?.with?.repository,\n      ...(options?.with?.lfs ? { lfs: true } : {}),\n    });\n\n    return {\n      ...this.buildJobStepConfig({\n        ...options,\n        name: options.name ?? \"Checkout\",\n      }),\n      uses: \"actions/checkout@v3\",\n      with: Object.keys(checkoutWith).length > 0 ? checkoutWith : undefined,\n    };\n  }\n\n  /**\n   * Configures the git identity (user name and email).\n   * @param options Options to configure the git identity JobStep\n   * @returns Job steps\n   */\n  public static setupGitIdentity(options: SetupGitIdentityOptions): JobStep {\n    return {\n      ...this.buildJobStepConfig({\n        ...options,\n        name: options.name ?? \"Set git identity\",\n      }),\n      run: [\n        `git config user.name \"${options.gitIdentity.name}\"`,\n        `git config user.email \"${options.gitIdentity.email}\"`,\n      ].join(\"\\n\"),\n    };\n  }\n\n  public static uploadArtifact(options: UploadArtifactOptions): JobStep {\n    const uploadArtifactWith: UploadArtifactWith =\n      removeNullOrUndefinedProperties({\n        name: options?.with?.name,\n        path: options?.with?.path,\n        \"if-no-files-found\": options?.with?.ifNoFilesFound,\n        \"retention-days\": options?.with?.retentionDays,\n        \"compression-level\": options?.with?.compressionLevel,\n      });\n\n    return {\n      ...this.buildJobStepConfig({\n        ...options,\n        name: options.name ?? \"Upload artifact\",\n      }),\n      uses: \"actions/upload-artifact@v3\",\n      with: uploadArtifactWith,\n    };\n  }\n\n  private static buildJobStepConfig(\n    options: JobStepConfiguration\n  ): JobStepConfiguration {\n    return {\n      continueOnError: options?.continueOnError,\n      env: options?.env,\n      id: options?.id,\n      if: options?.if,\n      name: options?.name,\n      timeoutMinutes: options?.timeoutMinutes,\n      workingDirectory: options?.workingDirectory,\n    };\n  }\n}\nexport interface CheckoutOptions extends JobStepConfiguration {\n  /**\n   * Options for `checkout`.\n   */\n  readonly with?: CheckoutWith;\n}\n\n/**\n * Options for `checkout`.\n */\nexport interface CheckoutWith {\n  /**\n   * Number of commits to fetch. 0 indicates all history for all branches and tags.\n   *\n   * @default 1\n   */\n  readonly fetchDepth?: number;\n  /**\n   * Whether LFS is enabled for the GitHub repository\n   *\n   * @default false\n   */\n  readonly lfs?: boolean;\n\n  /**\n   * Branch or tag name.\n   * @default - the default branch is implicitly used\n   */\n  readonly ref?: string;\n\n  /**\n   * The repository (owner/repo) to use.\n   * @default - the default repository is implicitly used\n   */\n  readonly repository?: string;\n\n  /**\n   * A GitHub token to use when checking out the repository.\n   *\n   * If the intent is to push changes back to the branch, then you must use a\n   * PAT with `repo` (and possibly `workflows`) permissions.\n   * @default - the default GITHUB_TOKEN is implicitly used\n   */\n  readonly token?: string;\n}\n\nexport interface SetupGitIdentityOptions extends JobStepConfiguration {\n  /**\n   * The identity to use.\n   */\n  readonly gitIdentity: GitIdentity;\n}\n\nexport interface UploadArtifactWith {\n  /**\n   * Name of the artifact to upload.\n   *\n   * @default \"artifact\"\n   */\n  readonly name?: string;\n\n  /**\n   * A file, directory or wildcard pattern that describes what to upload\n   */\n  readonly path: string;\n\n  /**\n   * The desired behavior if no files are found using the provided path.\n   * Available Options:\n   *   warn: Output a warning but do not fail the action\n   *   error: Fail the action with an error message\n   *   ignore: Do not output any warnings or errors, the action does not fail\n   *\n   * @default \"warn\"\n   */\n  readonly ifNoFilesFound?: \"error\" | \"warn\" | \"ignore\";\n\n  /**\n   * Duration after which artifact will expire in days. 0 means using default repository retention.\n   *\n   * Minimum 1 day.\n   * Maximum 90 days unless changed from the repository settings page.\n   *\n   * @default - The default repository retention\n   */\n  readonly retentionDays?: number;\n\n  /**\n   * The level of compression for Zlib to be applied to the artifact archive.\n   *\n   * The value can range from 0 to 9.\n   * For large files that are not easily compressed, a value of 0 is recommended for significantly faster uploads.\n   *\n   * @default 6\n   */\n  readonly compressionLevel?: number;\n}\n\nexport interface UploadArtifactOptions extends JobStepConfiguration {\n  /**\n   * Options for `upload-artifact`.\n   */\n  readonly with: UploadArtifactWith;\n}\n"]}

package/lib/github/workflows-model.d.ts

@@ -316,9 +316,12 @@ export interface RunSettings {
     readonly workingDirectory?: string;
 }
 /**
- * A generic step
+ * Fields that describe the How, Why, When, and Who of a Step.
+ * These fields can have none present, but can be present on every Step, and have no effect on one another.
+ *
+ * This stands in contrast to the Command (non-Configuration) fields, which are mutually exclusive, and describe the What.
  */
-export interface Step {
+export interface StepConfiguration {
     /**
      * A unique identifier for the step. You can use the id to reference the
      * step in contexts.
@@ -334,6 +337,26 @@ export interface Step {
      * A name for your step to display on GitHub.
      */
     readonly name?: string;
+    /**
+     * Sets environment variables for steps to use in the runner environment.
+     * You can also set environment variables for the entire workflow or a job.
+     */
+    readonly env?: Record<string, string>;
+    /**
+     * Specifies a working directory for a step.
+     * Overrides a job's working directory.
+     */
+    readonly workingDirectory?: string;
+}
+/**
+ * This contains the fields that are common amongst both:
+ * - JobStep, which is a step that is part of a Job in Github Actions. This is by far the most common use case.
+ * - The metadata file `action.yaml` that is used to define an Action when you are creating one. As in, if you were creating an Action to be used in a JobStep.
+ * There is some overlap between the two, and this captures that overlap.
+ *
+ * @see https://docs.github.com/en/actions/creating-actions/metadata-syntax-for-github-actions
+ */
+export interface Step extends StepConfiguration {
     /**
      * Selects an action to run as part of a step in your job. An action is a
      * reusable unit of code. You can use an action defined in the same
@@ -353,21 +376,12 @@ export interface Step {
      * The variable is prefixed with INPUT_ and converted to upper case.
      */
     readonly with?: Record<string, any>;
-    /**
-     * Sets environment variables for steps to use in the runner environment.
-     * You can also set environment variables for the entire workflow or a job.
-     */
-    readonly env?: Record<string, string>;
-    /**
-     * Specifies a working directory for a step.
-     * Overrides a job's working directory.
-     */
-    readonly workingDirectory?: string;
 }
 /**
- * A job step
+ * These settings are unique to a JobStep from the fields contained within the metadata action.yaml file present in when creating a new GitHub Action.
+ * These fields are not present in action.yml, but are in JobStep, which are using when creating workflows.
  */
-export interface JobStep extends Step {
+export interface JobStepConfiguration extends StepConfiguration {
     /**
      * Prevents a job from failing when a step fails. Set to true to allow a job
      * to pass when this step fails.
@@ -378,6 +392,13 @@ export interface JobStep extends Step {
      */
     readonly timeoutMinutes?: number;
 }
+/**
+ * JobSteps run as part of a GitHub Workflow Job.
+ *
+ * @see https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idsteps
+ */
+export interface JobStep extends Step, JobStepConfiguration {
+}
 /**
  * A strategy creates a build matrix for your jobs. You can define different
  * variations to run each job in.

package/lib/github/workflows-model.js

@@ -31,4 +31,4 @@ var AppPermission;
     AppPermission["ADMIN"] = "admin";
 })(AppPermission || (exports.AppPermission = AppPermission = {}));
 //#endregion
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflows-model.js","sourceRoot":"","sources":["../../src/github/workflows-model.ts"],"names":[],"mappings":";AAAA,uFAAuF;;;AAgSvF;;GAEG;AACH,IAAY,aASX;AATD,WAAY,aAAa;IACvB,uBAAuB;IACvB,8BAAa,CAAA;IAEb,wBAAwB;IACxB,gCAAe,CAAA;IAEf,uBAAuB;IACvB,8BAAa,CAAA;AACf,CAAC,EATW,aAAa,6BAAb,aAAa,QASxB;AAED;;GAEG;AACH,IAAY,aAWX;AAXD,WAAY,aAAa;IACvB,wBAAwB;IACxB,8BAAa,CAAA;IACb,wBAAwB;IACxB,gCAAe,CAAA;IACf;;;;OAIG;IACH,gCAAe,CAAA;AACjB,CAAC,EAXW,aAAa,6BAAb,aAAa,QAWxB;AAo6BD,YAAY","sourcesContent":["// @see https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions\n\nimport { GroupRunnerOptions } from \"../runner-options\";\n\nexport interface CommonJobDefinition {\n  /**\n   * The name of the job displayed on GitHub.\n   */\n  readonly name?: string;\n\n  /**\n   * Identifies any jobs that must complete successfully before this job will\n   * run. It can be a string or array of strings. If a job fails, all jobs\n   * that need it are skipped unless the jobs use a conditional expression\n   * that causes the job to continue.\n   */\n  readonly needs?: string[];\n\n  /**\n   * You can modify the default permissions granted to the GITHUB_TOKEN, adding\n   * or removing access as required, so that you only allow the minimum required\n   * access.\n   *\n   * Use `{ contents: READ }` if your job only needs to clone code.\n   *\n   * This is intentionally a required field since it is required in order to\n   * allow workflows to run in GitHub repositories with restricted default\n   * access.\n   *\n   * @see https://docs.github.com/en/actions/reference/authentication-in-a-workflow#permissions-for-the-github_token\n   */\n  readonly permissions: JobPermissions;\n\n  /**\n   * Concurrency ensures that only a single job or workflow using the same\n   * concurrency group will run at a time. A concurrency group can be any\n   * string or expression. The expression can use any context except for the\n   * secrets context.\n   *\n   * @experimental\n   */\n  readonly concurrency?: unknown;\n\n  /**\n   * You can use the if conditional to prevent a job from running unless a\n   * condition is met. You can use any supported context and expression to\n   * create a conditional.\n   */\n  readonly if?: string;\n\n  /**\n   * A strategy creates a build matrix for your jobs. You can define different\n   * variations to run each job in.\n   */\n  readonly strategy?: JobStrategy;\n}\n\n/**\n * A GitHub Workflow Job calling a reusable workflow\n *\n */\nexport interface JobCallingReusableWorkflow extends CommonJobDefinition {\n  /**\n   * The location and version of a reusable workflow file to run as a job.\n   */\n  readonly uses: string;\n\n  /**\n   * When a job is used to call a reusable workflow, you can use with to\n   * provide a map of inputs that are passed to the called workflow.\n   *\n   * Allowed expression contexts: `github`, and `needs`.\n   */\n  readonly with?: Record<string, string | boolean>;\n\n  /**\n   * When a job is used to call a reusable workflow, you can use secrets to\n   * provide a map of secrets that are passed to the called workflow.\n   *\n   * Use the 'inherit' keyword to pass all the calling workflow's secrets to the called workflow\n   */\n  readonly secrets?: string | Record<string, string>;\n}\n\n/**\n * A GitHub Workflow job definition.\n */\nexport interface Job extends CommonJobDefinition {\n  /**\n   * The type of machine to run the job on. The machine can be either a\n   * GitHub-hosted runner or a self-hosted runner.\n   *\n   * @example [\"ubuntu-latest\"]\n   */\n  readonly runsOn?: string[];\n\n  /**\n   * Github Runner Group selection options\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 runsOnGroup?: GroupRunnerOptions;\n\n  /**\n   * A job contains a sequence of tasks called steps. Steps can run commands,\n   * run setup tasks, or run an action in your repository, a public repository,\n   * or an action published in a Docker registry. Not all steps run actions,\n   * but all actions run as a step. Each step runs in its own process in the\n   * runner environment and has access to the workspace and filesystem.\n   * Because steps run in their own process, changes to environment variables\n   * are not preserved between steps. GitHub provides built-in steps to set up\n   * and complete a job.\n   */\n  readonly steps: JobStep[];\n\n  /**\n   * The environment that the job references. All environment protection rules\n   * must pass before a job referencing the environment is sent to a runner.\n   *\n   * @see https://docs.github.com/en/actions/reference/environments\n   */\n  readonly environment?: unknown;\n\n  /**\n   * A map of outputs for a job. Job outputs are available to all downstream\n   * jobs that depend on this job.\n   */\n  readonly outputs?: Record<string, JobStepOutput>;\n\n  /**\n   * A map of environment variables that are available to all steps in the\n   * job. You can also set environment variables for the entire workflow or an\n   * individual step.\n   */\n  readonly env?: Record<string, string>;\n\n  /**\n   * A map of default settings that will apply to all steps in the job. You\n   * can also set default settings for the entire workflow.\n   */\n  readonly defaults?: JobDefaults;\n\n  /**\n   * The maximum number of minutes to let a job run before GitHub\n   * automatically cancels it.\n   *\n   * @default 360\n   */\n  readonly timeoutMinutes?: number;\n\n  /**\n   * Prevents a workflow run from failing when a job fails. Set to true to\n   * allow a workflow run to pass when this job fails.\n   */\n  readonly continueOnError?: boolean;\n\n  /**\n   * A container to run any steps in a job that don't already specify a\n   * container. If you have steps that use both script and container actions,\n   * the container actions will run as sibling containers on the same network\n   * with the same volume mounts.\n   */\n  readonly container?: ContainerOptions;\n\n  /**\n   * Used to host service containers for a job in a workflow. Service\n   * containers are useful for creating databases or cache services like Redis.\n   * The runner automatically creates a Docker network and manages the life\n   * cycle of the service containers.\n   */\n  readonly services?: Record<string, ContainerOptions>;\n\n  /**\n   * Tools required for this job. Translates into `actions/setup-xxx` steps at\n   * the beginning of the job.\n   */\n  readonly tools?: Tools;\n}\n\n/**\n * Supported tools.\n */\nexport interface Tools {\n  /**\n   * Setup java (temurin distribution).\n   * @default - not installed\n   */\n  readonly java?: ToolRequirement;\n\n  /**\n   * Setup python.\n   * @default - not installed\n   */\n  readonly python?: ToolRequirement;\n\n  /**\n   * Setup golang.\n   * @default - not installed\n   */\n  readonly go?: ToolRequirement;\n\n  /**\n   * Setup node.js\n   * @default - not installed\n   */\n  readonly node?: ToolRequirement;\n\n  /**\n   * Setup .NET Core\n   * @default - not installed\n   */\n  readonly dotnet?: ToolRequirement;\n}\n\n/**\n * Version requirement for tools.\n */\nexport interface ToolRequirement {\n  readonly version: string;\n}\n\n/**\n * The available scopes and access values for workflow permissions. If you\n * specify the access for any of these scopes, all those that are not\n * specified are set to `JobPermission.NONE`, instead of the default behavior\n * when none is specified.\n */\nexport interface JobPermissions {\n  readonly actions?: JobPermission;\n  readonly checks?: JobPermission;\n  readonly contents?: JobPermission;\n  readonly deployments?: JobPermission;\n  readonly idToken?: JobPermission;\n  readonly issues?: JobPermission;\n  readonly discussions?: JobPermission;\n  readonly packages?: JobPermission;\n  readonly pages?: JobPermission;\n  readonly pullRequests?: JobPermission;\n  readonly repositoryProjects?: JobPermission;\n  readonly securityEvents?: JobPermission;\n  readonly statuses?: JobPermission;\n}\n\n/**\n * The permissions available to a GitHub App.\n *\n * Typically a token for a GitHub App has all the available scopes/permissions available to the app\n * itself; however, a more limited set of permissions can be specified. When permissions are provided,\n * **only** the specified permissions are granted to the token.\n *\n * @see https://docs.github.com/en/rest/apps/apps?apiVersion=2022-11-28#create-an-installation-access-token-for-an-app\n */\nexport interface AppPermissions {\n  readonly actions?: AppPermission;\n  readonly administration?: AppPermission;\n  readonly checks?: AppPermission;\n  readonly contents?: AppPermission;\n  readonly deployments?: AppPermission;\n  readonly environments?: AppPermission;\n  readonly issues?: AppPermission;\n  readonly metadata?: AppPermission;\n  readonly packages?: AppPermission;\n  readonly pages?: AppPermission;\n  readonly pullRequests?: AppPermission;\n  readonly repositoryAnnouncementBanners?: AppPermission;\n  readonly repositoryHooks?: AppPermission;\n  readonly repositoryProject?: AppPermission;\n  readonly secretScanningAlerts?: AppPermission;\n  readonly secrets?: AppPermission;\n  readonly securityEvents?: AppPermission;\n  readonly singleFile?: AppPermission;\n  readonly statuses?: AppPermission;\n  readonly vulnerabilityAlerts?: AppPermission;\n  readonly workflows?: AppPermission;\n  readonly members?: AppPermission;\n  readonly organizationAdministration?: AppPermission;\n  readonly organizationCustomRoles?: AppPermission;\n  readonly organizationAnnouncementBanners?: AppPermission;\n  readonly organizationHooks?: AppPermission;\n  readonly organizationPlan?: AppPermission;\n  readonly organizationProjects?: AppPermission;\n  readonly organizationPackages?: AppPermission;\n  readonly organizationSecrets?: AppPermission;\n  readonly organizationSelfHostedRunners?: AppPermission;\n  readonly orgnaizationUserBlocking?: AppPermission;\n  readonly teamDiscussions?: AppPermission;\n}\n\n/**\n * Access level for workflow permission scopes.\n */\nexport enum JobPermission {\n  /** Read-only access */\n  READ = \"read\",\n\n  /** Read-write access */\n  WRITE = \"write\",\n\n  /** No access at all */\n  NONE = \"none\",\n}\n\n/**\n * The permissions available for an access token for a GitHub App.\n */\nexport enum AppPermission {\n  /** Read-only acccess */\n  READ = \"read\",\n  /** Read-write access */\n  WRITE = \"write\",\n  /**\n   * Read-write and admin access.\n   *\n   * Not all permissions support `admin`.\n   */\n  ADMIN = \"admin\",\n}\n\n/**\n * An output binding for a job.\n */\nexport interface JobStepOutput {\n  /**\n   * The ID of the step that exposes the output.\n   */\n  readonly stepId: string;\n\n  /**\n   * The name of the job output that is being bound.\n   */\n  readonly outputName: string;\n}\n\n/**\n * Default settings for all steps in the job.\n */\nexport interface JobDefaults {\n  /** Default run settings. */\n  readonly run?: RunSettings;\n}\n\n/**\n * Run settings for a job.\n */\nexport interface RunSettings {\n  /**\n   * Which shell to use for running the step.\n   *\n   * @example \"bash\"\n   */\n  readonly shell?: string;\n\n  /**\n   * Working directory to use when running the step.\n   */\n  readonly workingDirectory?: string;\n}\n\n/**\n * A generic step\n */\nexport interface Step {\n  /**\n   * A unique identifier for the step. You can use the id to reference the\n   * step in contexts.\n   */\n  readonly id?: string;\n\n  /**\n   * You can use the if conditional to prevent a job from running unless a\n   * condition is met. You can use any supported context and expression to\n   * create a conditional.\n   */\n  readonly if?: string;\n\n  /**\n   * A name for your step to display on GitHub.\n   */\n  readonly name?: string;\n\n  /**\n   * Selects an action to run as part of a step in your job. An action is a\n   * reusable unit of code. You can use an action defined in the same\n   * repository as the workflow, a public repository, or in a published Docker\n   * container image.\n   */\n  readonly uses?: string;\n\n  /**\n   * Runs command-line programs using the operating system's shell. If you do\n   * not provide a name, the step name will default to the text specified in\n   * the run command.\n   */\n  readonly run?: string;\n\n  /**\n   * A map of the input parameters defined by the action. Each input parameter\n   * is a key/value pair. Input parameters are set as environment variables.\n   * The variable is prefixed with INPUT_ and converted to upper case.\n   */\n  readonly with?: Record<string, any>;\n\n  /**\n   * Sets environment variables for steps to use in the runner environment.\n   * You can also set environment variables for the entire workflow or a job.\n   */\n  readonly env?: Record<string, string>;\n\n  /**\n   * Specifies a working directory for a step.\n   * Overrides a job's working directory.\n   */\n  readonly workingDirectory?: string;\n}\n\n/**\n * A job step\n */\nexport interface JobStep extends Step {\n  /**\n   * Prevents a job from failing when a step fails. Set to true to allow a job\n   * to pass when this step fails.\n   */\n  readonly continueOnError?: boolean;\n\n  /**\n   * The maximum number of minutes to run the step before killing the process.\n   */\n  readonly timeoutMinutes?: number;\n}\n\n/**\n * A strategy creates a build matrix for your jobs. You can define different\n * variations to run each job in.\n */\nexport interface JobStrategy {\n  /**\n   * You can define a matrix of different job configurations. A matrix allows\n   * you to create multiple jobs by performing variable substitution in a\n   * single job definition. For example, you can use a matrix to create jobs\n   * for more than one supported version of a programming language, operating\n   * system, or tool. A matrix reuses the job's configuration and creates a\n   * job for each matrix you configure.\n   *\n   * A job matrix can generate a maximum of 256 jobs per workflow run. This\n   * limit also applies to self-hosted runners.\n   */\n  readonly matrix?: JobMatrix;\n\n  /**\n   * When set to true, GitHub cancels all in-progress jobs if any matrix job\n   * fails. Default: true\n   */\n  readonly failFast?: boolean;\n\n  /**\n   * The maximum number of jobs that can run simultaneously when using a\n   * matrix job strategy. By default, GitHub will maximize the number of jobs\n   * run in parallel depending on the available runners on GitHub-hosted\n   * virtual machines.\n   */\n  readonly maxParallel?: number;\n}\n\ntype JobMatrixValue = string | boolean | number;\n\n/**\n * A job matrix.\n */\nexport interface JobMatrix {\n  /**\n   * Each option you define in the matrix has a key and value. The keys you\n   * define become properties in the matrix context and you can reference the\n   * property in other areas of your workflow file. For example, if you define\n   * the key os that contains an array of operating systems, you can use the\n   * matrix.os property as the value of the runs-on keyword to create a job\n   * for each operating system.\n   */\n  readonly domain?: Record<string, JobMatrixValue[]>;\n\n  /**\n   * You can add additional configuration options to a build matrix job that\n   * already exists. For example, if you want to use a specific version of npm\n   * when the job that uses windows-latest and version 8 of node runs, you can\n   * use include to specify that additional option.\n   */\n  readonly include?: Array<Record<string, JobMatrixValue>>;\n\n  /**\n   * You can remove a specific configurations defined in the build matrix\n   * using the exclude option. Using exclude removes a job defined by the\n   * build matrix.\n   */\n  readonly exclude?: Array<Record<string, JobMatrixValue>>;\n}\n\n/**\n * Options pertaining to container environments.\n */\nexport interface ContainerOptions {\n  /**\n   * The Docker image to use as the container to run the action. The value can\n   * be the Docker Hub image name or a registry name.\n   */\n  readonly image: string;\n\n  /**\n   * f the image's container registry requires authentication to pull the\n   * image, you can use credentials to set a map of the username and password.\n   * The credentials are the same values that you would provide to the docker\n   * login command.\n   */\n  readonly credentials?: ContainerCredentials;\n\n  /**\n   * Sets a map of environment variables in the container.\n   */\n  readonly env?: Record<string, string>;\n\n  /**\n   * Sets an array of ports to expose on the container.\n   */\n  readonly ports?: number[];\n\n  /**\n   * Sets an array of volumes for the container to use. You can use volumes to\n   * share data between services or other steps in a job. You can specify\n   * named Docker volumes, anonymous Docker volumes, or bind mounts on the\n   * host.\n   *\n   * To specify a volume, you specify the source and destination path:\n   * `<source>:<destinationPath>`.\n   */\n  readonly volumes?: string[];\n\n  /**\n   * Additional Docker container resource options.\n   *\n   * @see https://docs.docker.com/engine/reference/commandline/create/#options\n   */\n  readonly options?: string[];\n}\n\n/**\n * Credentials to use to authenticate to Docker registries.\n */\nexport interface ContainerCredentials {\n  /** The username. */\n  readonly username: string;\n\n  /** The password. */\n  readonly password: string;\n}\n\n/**\n * The set of available triggers for GitHub Workflows.\n *\n * @see https://docs.github.com/en/actions/reference/events-that-trigger-workflows\n */\nexport interface Triggers {\n  //#region Scheduled events\n  /**\n   * You can schedule a workflow to run at specific UTC times using POSIX cron\n   * syntax. Scheduled workflows run on the latest commit on the default or\n   * base branch. The shortest interval you can run scheduled workflows is\n   * once every 5 minutes.\n   *\n   * @see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/crontab.html#tag_20_25_07\n   */\n  readonly schedule?: CronScheduleOptions[];\n  //#endregion\n\n  //#region Manual events\n  /**\n   * You can configure custom-defined input properties, default input values,\n   * and required inputs for the event directly in your workflow. When the\n   * workflow runs, you can access the input values in the github.event.inputs\n   * context.\n   */\n  readonly workflowDispatch?: WorkflowDispatchOptions;\n\n  /**\n   * You can use the GitHub API to trigger a webhook event called\n   * repository_dispatch when you want to trigger a workflow for activity that\n   * happens outside of GitHub.\n   */\n  readonly repositoryDispatch?: RepositoryDispatchOptions;\n  //#endregion\n\n  //#region Workflow reuse events\n  /**\n   * Can be called from another workflow\n   * @see https://docs.github.com/en/actions/learn-github-actions/reusing-workflows\n   */\n  readonly workflowCall?: WorkflowCallOptions;\n  //#endregion\n\n  //#region Webhook events\n  /**\n   * Runs your workflow anytime the branch_protection_rule event occurs.\n   */\n  readonly branchProtectionRule?: BranchProtectionRuleOptions;\n\n  /**\n   * Runs your workflow anytime the check_run event occurs.\n   */\n  readonly checkRun?: CheckRunOptions;\n\n  /**\n   * Runs your workflow anytime the check_suite event occurs.\n   */\n  readonly checkSuite?: CheckSuiteOptions;\n\n  /**\n   * Runs your workflow anytime someone creates a branch or tag, which\n   * triggers the create event.\n   */\n  readonly create?: CreateOptions;\n\n  /**\n   * Runs your workflow anytime someone deletes a branch or tag, which\n   * triggers the delete event.\n   */\n  readonly delete?: DeleteOptions;\n\n  /**\n   * Runs your workflow anytime someone creates a deployment, which triggers\n   * the deployment event. Deployments created with a commit SHA may not have\n   * a Git ref.\n   */\n  readonly deployment?: DeploymentOptions;\n\n  /**\n   * Runs your workflow anytime a third party provides a deployment status,\n   * which triggers the deployment_status event. Deployments created with a\n   * commit SHA may not have a Git ref.\n   */\n  readonly deploymentStatus?: DeploymentStatusOptions;\n\n  /**\n   * Runs your workflow anytime the discussion event occurs. More than one activity type triggers this event.\n   * @see https://docs.github.com/en/graphql/guides/using-the-graphql-api-for-discussions\n   */\n  readonly discussion?: DiscussionOptions;\n\n  /**\n   * Runs your workflow anytime the discussion_comment event occurs. More than one activity type triggers this event.\n   * @see https://docs.github.com/en/graphql/guides/using-the-graphql-api-for-discussions\n   */\n  readonly discussionComment?: DiscussionCommentOptions;\n\n  /**\n   * Runs your workflow anytime when someone forks a repository, which\n   * triggers the fork event.\n   */\n  readonly fork?: ForkOptions;\n\n  /**\n   * Runs your workflow when someone creates or updates a Wiki page, which\n   * triggers the gollum event.\n   */\n  readonly gollum?: GollumOptions;\n\n  /**\n   * Runs your workflow anytime the issue_comment event occurs.\n   */\n  readonly issueComment?: IssueCommentOptions;\n\n  /**\n   * Runs your workflow anytime the issues event occurs.\n   */\n  readonly issues?: IssuesOptions;\n\n  /**\n   * Runs your workflow anytime the label event occurs.\n   */\n  readonly label?: LabelOptions;\n\n  /**\n   * Runs your workflow when a pull request is added to a merge queue, which\n   * adds the pull request to a merge group.\n   *\n   * @stability experimental\n   */\n  readonly mergeGroup?: MergeGroupOptions;\n\n  /**\n   * Runs your workflow anytime the milestone event occurs.\n   */\n  readonly milestone?: MilestoneOptions;\n\n  /**\n   * Runs your workflow anytime someone pushes to a GitHub Pages-enabled\n   * branch, which triggers the page_build event.\n   */\n  readonly pageBuild?: PageBuildOptions;\n\n  /**\n   * Runs your workflow anytime the project event occurs.\n   */\n  readonly project?: ProjectOptions;\n\n  /**\n   * Runs your workflow anytime the project_card event occurs.\n   */\n  readonly projectCard?: ProjectCardOptions;\n\n  /**\n   * Runs your workflow anytime the project_column event occurs.\n   */\n  readonly projectColumn?: ProjectColumnOptions;\n\n  /**\n   * Runs your workflow anytime someone makes a private repository public,\n   * which triggers the public event.\n   */\n  readonly public?: PublicOptions;\n\n  /**\n   * Runs your workflow anytime the pull_request event occurs.\n   */\n  readonly pullRequest?: PullRequestOptions;\n\n  /**\n   * Runs your workflow anytime the pull_request_review event occurs.\n   */\n  readonly pullRequestReview?: PullRequestReviewOptions;\n\n  /**\n   * Runs your workflow anytime a comment on a pull request's unified diff is\n   * modified, which triggers the pull_request_review_comment event.\n   */\n  readonly pullRequestReviewComment?: PullRequestReviewCommentOptions;\n\n  /**\n   * This event runs in the context of the base of the pull request, rather\n   * than in the merge commit as the pull_request event does. This prevents\n   * executing unsafe workflow code from the head of the pull request that\n   * could alter your repository or steal any secrets you use in your workflow.\n   * This event allows you to do things like create workflows that label and\n   * comment on pull requests based on the contents of the event payload.\n   *\n   * WARNING: The `pull_request_target` event is granted read/write repository\n   * token and can access secrets, even when it is triggered from a fork.\n   * Although the workflow runs in the context of the base of the pull request,\n   * you should make sure that you do not check out, build, or run untrusted\n   * code from the pull request with this event. Additionally, any caches\n   * share the same scope as the base branch, and to help prevent cache\n   * poisoning, you should not save the cache if there is a possibility that\n   * the cache contents were altered.\n   *\n   * @see https://securitylab.github.com/research/github-actions-preventing-pwn-requests\n   */\n  readonly pullRequestTarget?: PullRequestTargetOptions;\n\n  /**\n   * Runs your workflow when someone pushes to a repository branch, which\n   * triggers the push event.\n   */\n  readonly push?: PushOptions;\n\n  /**\n   * Runs your workflow anytime a package is published or updated.\n   */\n  readonly registryPackage?: RegistryPackageOptions;\n\n  /**\n   * Runs your workflow anytime the release event occurs.\n   */\n  readonly release?: ReleaseOptions;\n\n  /**\n   * Runs your workflow anytime the status of a Git commit changes, which\n   * triggers the status event.\n   */\n  readonly status?: StatusOptions;\n\n  /**\n   * Runs your workflow anytime the watch event occurs.\n   */\n  readonly watch?: WatchOptions;\n\n  /**\n   * This event occurs when a workflow run is requested or completed, and\n   * allows you to execute a workflow based on the finished result of another\n   * workflow. A workflow run is triggered regardless of the result of the\n   * previous workflow.\n   */\n  readonly workflowRun?: WorkflowRunOptions;\n  //#endregion\n}\n\n/**\n * CRON schedule options.\n */\nexport interface CronScheduleOptions {\n  /**\n   * @see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/crontab.html#tag_20_25_07\n   */\n  readonly cron: string;\n}\n\n/**\n * Repository dispatch options.\n */\nexport interface RepositoryDispatchOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: string[];\n}\n\n/**\n * Branch Protection Rule options\n */\nexport interface BranchProtectionRuleOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"created\" | \"edited\" | \"deleted\">;\n}\n\n/**\n * Check run options.\n */\nexport interface CheckRunOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    \"create\" | \"rerequested\" | \"completed\" | \"requested_action\"\n  >;\n}\n\n/**\n * Check suite options\n */\nexport interface CheckSuiteOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"completed\" | \"requested\" | \"rerequested\">;\n}\n\n/**\n * Discussion options\n */\nexport interface DiscussionOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    | \"created\"\n    | \"edited\"\n    | \"transferred\"\n    | \"pinned\"\n    | \"unpinned\"\n    | \"labeled\"\n    | \"unlabeled\"\n    | \"locked\"\n    | \"unlocked\"\n    | \"category_changed\"\n    | \"answered\"\n    | \"unanswered\"\n  >;\n}\n\n/**\n * Discussion comment options\n */\nexport interface DiscussionCommentOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"created\" | \"edited\" | \"deleted\">;\n}\n\n/**\n * Issue comment options\n */\nexport interface IssueCommentOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"created\" | \"edited\" | \"deleted\">;\n}\n\n/**\n * Issues options\n */\nexport interface IssuesOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    | \"opened\"\n    | \"edited\"\n    | \"deleted\"\n    | \"transferred\"\n    | \"pinned\"\n    | \"unpinned\"\n    | \"closed\"\n    | \"reopened\"\n    | \"assigned\"\n    | \"unassigned\"\n    | \"labeled\"\n    | \"unlabeled\"\n    | \"locked\"\n    | \"unlocked\"\n    | \"milestoned\"\n    | \"demilestoned\"\n  >;\n}\n\n/**\n * Label options\n */\nexport interface LabelOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"created\" | \"edited\" | \"deleted\">;\n}\n\n/**\n * Merge group options.\n *\n * @stability experimental\n */\nexport interface MergeGroupOptions {\n  /**\n   * When using the merge_group events, you can configure a workflow\n   * to run on specific base branches. If not specified, all branches will\n   * trigger the workflow.\n   */\n  readonly branches?: string[];\n}\n\n/**\n * Milestone options\n */\nexport interface MilestoneOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    \"created\" | \"closed\" | \"opened\" | \"edited\" | \"deleted\"\n  >;\n}\n\n/**\n * Project options\n */\nexport interface ProjectOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    \"created\" | \"updated\" | \"closed\" | \"reopened\" | \"edited\" | \"deleted\"\n  >;\n}\n\n/**\n * Project card options\n */\nexport interface ProjectCardOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    \"created\" | \"moved\" | \"converted\" | \"edited\" | \"deleted\"\n  >;\n}\n\n/**\n * Probject column options\n */\nexport interface ProjectColumnOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"created\" | \"updated\" | \"moved\" | \"deleted\">;\n}\n\n/**\n * Pull request options\n */\nexport interface PullRequestOptions extends PushOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    | \"assigned\"\n    | \"unassigned\"\n    | \"labeled\"\n    | \"unlabeled\"\n    | \"opened\"\n    | \"edited\"\n    | \"closed\"\n    | \"reopened\"\n    | \"synchronize\"\n    | \"ready_for_review\"\n    | \"locked\"\n    | \"unlocked\"\n    | \"review_requested\"\n    | \"review_request_removed\"\n  >;\n}\n\n/**\n * Pull request review options\n */\nexport interface PullRequestReviewOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"submitted\" | \"edited\" | \"dismissed\">;\n}\n\n/**\n * Pull request review comment options\n */\nexport interface PullRequestReviewCommentOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"created\" | \"edited\" | \"deleted\">;\n}\n\n/**\n * Pull request target options.\n */\nexport interface PullRequestTargetOptions extends PushOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    | \"assigned\"\n    | \"unassigned\"\n    | \"labeled\"\n    | \"unlabeled\"\n    | \"opened\"\n    | \"edited\"\n    | \"closed\"\n    | \"reopened\"\n    | \"synchronize\"\n    | \"ready_for_review\"\n    | \"locked\"\n    | \"unlocked\"\n    | \"review_requested\"\n    | \"review_request_removed\"\n  >;\n}\n\n/**\n * Options for push-like events.\n */\nexport interface PushOptions {\n  /**\n   * When using the push, pull_request and pull_request_target events, you can configure a workflow\n   * to run on specific branches or tags. For a pull_request event, only\n   * branches and tags on the base are evaluated. If you define only tags or\n   * only branches, the workflow won't run for events affecting the undefined\n   * Git ref.\n   *\n   * @see https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet\n   */\n  readonly branches?: string[];\n\n  /**\n   * When using the push, pull_request and pull_request_target events, you can configure a workflow\n   * to run on specific branches or tags. For a pull_request event, only\n   * branches and tags on the base are evaluated. If you define only tags or\n   * only branches, the workflow won't run for events affecting the undefined\n   * Git ref.\n   *\n   * @see https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet\n   */\n  readonly tags?: string[];\n\n  /**\n   * When using the push, pull_request and pull_request_target events, you can configure a workflow\n   * to run when at least one file does not match paths-ignore or at least one\n   * modified file matches the configured paths. Path filters are not\n   * evaluated for pushes to tags.\n   *\n   * @see https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet\n   */\n  readonly paths?: string[];\n}\n\n/**\n * Registry package options\n */\nexport interface RegistryPackageOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"published\" | \"updated\">;\n}\n\n/**\n * Release options\n */\nexport interface ReleaseOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    | \"published\"\n    | \"unpublished\"\n    | \"created\"\n    | \"edited\"\n    | \"deleted\"\n    | \"prereleased\"\n    | \"released\"\n  >;\n}\n\n/**\n * Watch options\n */\nexport interface WatchOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"started\">;\n}\n\n/**\n * Workflow run options\n */\nexport interface WorkflowRunOptions {\n  /**\n   * Which workflow to trigger on.\n   *\n   * @defaults - any workflows\n   */\n  readonly workflows?: Array<string>;\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"completed\" | \"requested\">;\n  /**\n   * Which branches or branch-ignore to limit the trigger to.\n   *\n   * @defaults - no branch limits\n   */\n  readonly branches?: Array<string>;\n}\n\n//#region Empty Options (future-proofing the API)\n/**\n * The Workflow dispatch event accepts no options.\n */\nexport interface WorkflowDispatchOptions {}\n\n/**\n * The Workflow Call event accepts no options.\n */\nexport interface WorkflowCallOptions {}\n\n/**\n * The Create event accepts no options.\n */\nexport interface CreateOptions {}\n\n/**\n * The Delete event accepts no options.\n */\nexport interface DeleteOptions {}\n\n/**\n * The Deployment event accepts no options.\n */\nexport interface DeploymentOptions {}\n\n/**\n * The Deployment status event accepts no options.\n */\nexport interface DeploymentStatusOptions {}\n\n/**\n * The Fork event accepts no options.\n */\nexport interface ForkOptions {}\n\n/**\n * The Gollum event accepts no options.\n */\nexport interface GollumOptions {}\n\n/**\n * The Page build event accepts no options.\n */\nexport interface PageBuildOptions {}\n\n/**\n * The Public event accepts no options.\n */\nexport interface PublicOptions {}\n\n/**\n * The Status event accepts no options.\n */\nexport interface StatusOptions {}\n//#endregion\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflows-model.js","sourceRoot":"","sources":["../../src/github/workflows-model.ts"],"names":[],"mappings":";AAAA,uFAAuF;;;AAgSvF;;GAEG;AACH,IAAY,aASX;AATD,WAAY,aAAa;IACvB,uBAAuB;IACvB,8BAAa,CAAA;IAEb,wBAAwB;IACxB,gCAAe,CAAA;IAEf,uBAAuB;IACvB,8BAAa,CAAA;AACf,CAAC,EATW,aAAa,6BAAb,aAAa,QASxB;AAED;;GAEG;AACH,IAAY,aAWX;AAXD,WAAY,aAAa;IACvB,wBAAwB;IACxB,8BAAa,CAAA;IACb,wBAAwB;IACxB,gCAAe,CAAA;IACf;;;;OAIG;IACH,gCAAe,CAAA;AACjB,CAAC,EAXW,aAAa,6BAAb,aAAa,QAWxB;AAy7BD,YAAY","sourcesContent":["// @see https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions\n\nimport { GroupRunnerOptions } from \"../runner-options\";\n\nexport interface CommonJobDefinition {\n  /**\n   * The name of the job displayed on GitHub.\n   */\n  readonly name?: string;\n\n  /**\n   * Identifies any jobs that must complete successfully before this job will\n   * run. It can be a string or array of strings. If a job fails, all jobs\n   * that need it are skipped unless the jobs use a conditional expression\n   * that causes the job to continue.\n   */\n  readonly needs?: string[];\n\n  /**\n   * You can modify the default permissions granted to the GITHUB_TOKEN, adding\n   * or removing access as required, so that you only allow the minimum required\n   * access.\n   *\n   * Use `{ contents: READ }` if your job only needs to clone code.\n   *\n   * This is intentionally a required field since it is required in order to\n   * allow workflows to run in GitHub repositories with restricted default\n   * access.\n   *\n   * @see https://docs.github.com/en/actions/reference/authentication-in-a-workflow#permissions-for-the-github_token\n   */\n  readonly permissions: JobPermissions;\n\n  /**\n   * Concurrency ensures that only a single job or workflow using the same\n   * concurrency group will run at a time. A concurrency group can be any\n   * string or expression. The expression can use any context except for the\n   * secrets context.\n   *\n   * @experimental\n   */\n  readonly concurrency?: unknown;\n\n  /**\n   * You can use the if conditional to prevent a job from running unless a\n   * condition is met. You can use any supported context and expression to\n   * create a conditional.\n   */\n  readonly if?: string;\n\n  /**\n   * A strategy creates a build matrix for your jobs. You can define different\n   * variations to run each job in.\n   */\n  readonly strategy?: JobStrategy;\n}\n\n/**\n * A GitHub Workflow Job calling a reusable workflow\n *\n */\nexport interface JobCallingReusableWorkflow extends CommonJobDefinition {\n  /**\n   * The location and version of a reusable workflow file to run as a job.\n   */\n  readonly uses: string;\n\n  /**\n   * When a job is used to call a reusable workflow, you can use with to\n   * provide a map of inputs that are passed to the called workflow.\n   *\n   * Allowed expression contexts: `github`, and `needs`.\n   */\n  readonly with?: Record<string, string | boolean>;\n\n  /**\n   * When a job is used to call a reusable workflow, you can use secrets to\n   * provide a map of secrets that are passed to the called workflow.\n   *\n   * Use the 'inherit' keyword to pass all the calling workflow's secrets to the called workflow\n   */\n  readonly secrets?: string | Record<string, string>;\n}\n\n/**\n * A GitHub Workflow job definition.\n */\nexport interface Job extends CommonJobDefinition {\n  /**\n   * The type of machine to run the job on. The machine can be either a\n   * GitHub-hosted runner or a self-hosted runner.\n   *\n   * @example [\"ubuntu-latest\"]\n   */\n  readonly runsOn?: string[];\n\n  /**\n   * Github Runner Group selection options\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 runsOnGroup?: GroupRunnerOptions;\n\n  /**\n   * A job contains a sequence of tasks called steps. Steps can run commands,\n   * run setup tasks, or run an action in your repository, a public repository,\n   * or an action published in a Docker registry. Not all steps run actions,\n   * but all actions run as a step. Each step runs in its own process in the\n   * runner environment and has access to the workspace and filesystem.\n   * Because steps run in their own process, changes to environment variables\n   * are not preserved between steps. GitHub provides built-in steps to set up\n   * and complete a job.\n   */\n  readonly steps: JobStep[];\n\n  /**\n   * The environment that the job references. All environment protection rules\n   * must pass before a job referencing the environment is sent to a runner.\n   *\n   * @see https://docs.github.com/en/actions/reference/environments\n   */\n  readonly environment?: unknown;\n\n  /**\n   * A map of outputs for a job. Job outputs are available to all downstream\n   * jobs that depend on this job.\n   */\n  readonly outputs?: Record<string, JobStepOutput>;\n\n  /**\n   * A map of environment variables that are available to all steps in the\n   * job. You can also set environment variables for the entire workflow or an\n   * individual step.\n   */\n  readonly env?: Record<string, string>;\n\n  /**\n   * A map of default settings that will apply to all steps in the job. You\n   * can also set default settings for the entire workflow.\n   */\n  readonly defaults?: JobDefaults;\n\n  /**\n   * The maximum number of minutes to let a job run before GitHub\n   * automatically cancels it.\n   *\n   * @default 360\n   */\n  readonly timeoutMinutes?: number;\n\n  /**\n   * Prevents a workflow run from failing when a job fails. Set to true to\n   * allow a workflow run to pass when this job fails.\n   */\n  readonly continueOnError?: boolean;\n\n  /**\n   * A container to run any steps in a job that don't already specify a\n   * container. If you have steps that use both script and container actions,\n   * the container actions will run as sibling containers on the same network\n   * with the same volume mounts.\n   */\n  readonly container?: ContainerOptions;\n\n  /**\n   * Used to host service containers for a job in a workflow. Service\n   * containers are useful for creating databases or cache services like Redis.\n   * The runner automatically creates a Docker network and manages the life\n   * cycle of the service containers.\n   */\n  readonly services?: Record<string, ContainerOptions>;\n\n  /**\n   * Tools required for this job. Translates into `actions/setup-xxx` steps at\n   * the beginning of the job.\n   */\n  readonly tools?: Tools;\n}\n\n/**\n * Supported tools.\n */\nexport interface Tools {\n  /**\n   * Setup java (temurin distribution).\n   * @default - not installed\n   */\n  readonly java?: ToolRequirement;\n\n  /**\n   * Setup python.\n   * @default - not installed\n   */\n  readonly python?: ToolRequirement;\n\n  /**\n   * Setup golang.\n   * @default - not installed\n   */\n  readonly go?: ToolRequirement;\n\n  /**\n   * Setup node.js\n   * @default - not installed\n   */\n  readonly node?: ToolRequirement;\n\n  /**\n   * Setup .NET Core\n   * @default - not installed\n   */\n  readonly dotnet?: ToolRequirement;\n}\n\n/**\n * Version requirement for tools.\n */\nexport interface ToolRequirement {\n  readonly version: string;\n}\n\n/**\n * The available scopes and access values for workflow permissions. If you\n * specify the access for any of these scopes, all those that are not\n * specified are set to `JobPermission.NONE`, instead of the default behavior\n * when none is specified.\n */\nexport interface JobPermissions {\n  readonly actions?: JobPermission;\n  readonly checks?: JobPermission;\n  readonly contents?: JobPermission;\n  readonly deployments?: JobPermission;\n  readonly idToken?: JobPermission;\n  readonly issues?: JobPermission;\n  readonly discussions?: JobPermission;\n  readonly packages?: JobPermission;\n  readonly pages?: JobPermission;\n  readonly pullRequests?: JobPermission;\n  readonly repositoryProjects?: JobPermission;\n  readonly securityEvents?: JobPermission;\n  readonly statuses?: JobPermission;\n}\n\n/**\n * The permissions available to a GitHub App.\n *\n * Typically a token for a GitHub App has all the available scopes/permissions available to the app\n * itself; however, a more limited set of permissions can be specified. When permissions are provided,\n * **only** the specified permissions are granted to the token.\n *\n * @see https://docs.github.com/en/rest/apps/apps?apiVersion=2022-11-28#create-an-installation-access-token-for-an-app\n */\nexport interface AppPermissions {\n  readonly actions?: AppPermission;\n  readonly administration?: AppPermission;\n  readonly checks?: AppPermission;\n  readonly contents?: AppPermission;\n  readonly deployments?: AppPermission;\n  readonly environments?: AppPermission;\n  readonly issues?: AppPermission;\n  readonly metadata?: AppPermission;\n  readonly packages?: AppPermission;\n  readonly pages?: AppPermission;\n  readonly pullRequests?: AppPermission;\n  readonly repositoryAnnouncementBanners?: AppPermission;\n  readonly repositoryHooks?: AppPermission;\n  readonly repositoryProject?: AppPermission;\n  readonly secretScanningAlerts?: AppPermission;\n  readonly secrets?: AppPermission;\n  readonly securityEvents?: AppPermission;\n  readonly singleFile?: AppPermission;\n  readonly statuses?: AppPermission;\n  readonly vulnerabilityAlerts?: AppPermission;\n  readonly workflows?: AppPermission;\n  readonly members?: AppPermission;\n  readonly organizationAdministration?: AppPermission;\n  readonly organizationCustomRoles?: AppPermission;\n  readonly organizationAnnouncementBanners?: AppPermission;\n  readonly organizationHooks?: AppPermission;\n  readonly organizationPlan?: AppPermission;\n  readonly organizationProjects?: AppPermission;\n  readonly organizationPackages?: AppPermission;\n  readonly organizationSecrets?: AppPermission;\n  readonly organizationSelfHostedRunners?: AppPermission;\n  readonly orgnaizationUserBlocking?: AppPermission;\n  readonly teamDiscussions?: AppPermission;\n}\n\n/**\n * Access level for workflow permission scopes.\n */\nexport enum JobPermission {\n  /** Read-only access */\n  READ = \"read\",\n\n  /** Read-write access */\n  WRITE = \"write\",\n\n  /** No access at all */\n  NONE = \"none\",\n}\n\n/**\n * The permissions available for an access token for a GitHub App.\n */\nexport enum AppPermission {\n  /** Read-only acccess */\n  READ = \"read\",\n  /** Read-write access */\n  WRITE = \"write\",\n  /**\n   * Read-write and admin access.\n   *\n   * Not all permissions support `admin`.\n   */\n  ADMIN = \"admin\",\n}\n\n/**\n * An output binding for a job.\n */\nexport interface JobStepOutput {\n  /**\n   * The ID of the step that exposes the output.\n   */\n  readonly stepId: string;\n\n  /**\n   * The name of the job output that is being bound.\n   */\n  readonly outputName: string;\n}\n\n/**\n * Default settings for all steps in the job.\n */\nexport interface JobDefaults {\n  /** Default run settings. */\n  readonly run?: RunSettings;\n}\n\n/**\n * Run settings for a job.\n */\nexport interface RunSettings {\n  /**\n   * Which shell to use for running the step.\n   *\n   * @example \"bash\"\n   */\n  readonly shell?: string;\n\n  /**\n   * Working directory to use when running the step.\n   */\n  readonly workingDirectory?: string;\n}\n\n/**\n * Fields that describe the How, Why, When, and Who of a Step.\n * These fields can have none present, but can be present on every Step, and have no effect on one another.\n *\n * This stands in contrast to the Command (non-Configuration) fields, which are mutually exclusive, and describe the What.\n */\nexport interface StepConfiguration {\n  /**\n   * A unique identifier for the step. You can use the id to reference the\n   * step in contexts.\n   */\n  readonly id?: string;\n\n  /**\n   * You can use the if conditional to prevent a job from running unless a\n   * condition is met. You can use any supported context and expression to\n   * create a conditional.\n   */\n  readonly if?: string;\n\n  /**\n   * A name for your step to display on GitHub.\n   */\n  readonly name?: string;\n\n  /**\n   * Sets environment variables for steps to use in the runner environment.\n   * You can also set environment variables for the entire workflow or a job.\n   */\n  readonly env?: Record<string, string>;\n\n  /**\n   * Specifies a working directory for a step.\n   * Overrides a job's working directory.\n   */\n  readonly workingDirectory?: string;\n}\n\n/**\n * This contains the fields that are common amongst both:\n * - JobStep, which is a step that is part of a Job in Github Actions. This is by far the most common use case.\n * - The metadata file `action.yaml` that is used to define an Action when you are creating one. As in, if you were creating an Action to be used in a JobStep.\n * There is some overlap between the two, and this captures that overlap.\n *\n * @see https://docs.github.com/en/actions/creating-actions/metadata-syntax-for-github-actions\n */\nexport interface Step extends StepConfiguration {\n  /**\n   * Selects an action to run as part of a step in your job. An action is a\n   * reusable unit of code. You can use an action defined in the same\n   * repository as the workflow, a public repository, or in a published Docker\n   * container image.\n   */\n  readonly uses?: string;\n\n  /**\n   * Runs command-line programs using the operating system's shell. If you do\n   * not provide a name, the step name will default to the text specified in\n   * the run command.\n   */\n  readonly run?: string;\n\n  /**\n   * A map of the input parameters defined by the action. Each input parameter\n   * is a key/value pair. Input parameters are set as environment variables.\n   * The variable is prefixed with INPUT_ and converted to upper case.\n   */\n  readonly with?: Record<string, any>;\n}\n\n/**\n * These settings are unique to a JobStep from the fields contained within the metadata action.yaml file present in when creating a new GitHub Action.\n * These fields are not present in action.yml, but are in JobStep, which are using when creating workflows.\n */\nexport interface JobStepConfiguration extends StepConfiguration {\n  /**\n   * Prevents a job from failing when a step fails. Set to true to allow a job\n   * to pass when this step fails.\n   */\n  readonly continueOnError?: boolean;\n\n  /**\n   * The maximum number of minutes to run the step before killing the process.\n   */\n  readonly timeoutMinutes?: number;\n}\n\n/**\n * JobSteps run as part of a GitHub Workflow Job.\n *\n * @see https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idsteps\n */\nexport interface JobStep extends Step, JobStepConfiguration {}\n\n/**\n * A strategy creates a build matrix for your jobs. You can define different\n * variations to run each job in.\n */\nexport interface JobStrategy {\n  /**\n   * You can define a matrix of different job configurations. A matrix allows\n   * you to create multiple jobs by performing variable substitution in a\n   * single job definition. For example, you can use a matrix to create jobs\n   * for more than one supported version of a programming language, operating\n   * system, or tool. A matrix reuses the job's configuration and creates a\n   * job for each matrix you configure.\n   *\n   * A job matrix can generate a maximum of 256 jobs per workflow run. This\n   * limit also applies to self-hosted runners.\n   */\n  readonly matrix?: JobMatrix;\n\n  /**\n   * When set to true, GitHub cancels all in-progress jobs if any matrix job\n   * fails. Default: true\n   */\n  readonly failFast?: boolean;\n\n  /**\n   * The maximum number of jobs that can run simultaneously when using a\n   * matrix job strategy. By default, GitHub will maximize the number of jobs\n   * run in parallel depending on the available runners on GitHub-hosted\n   * virtual machines.\n   */\n  readonly maxParallel?: number;\n}\n\ntype JobMatrixValue = string | boolean | number;\n\n/**\n * A job matrix.\n */\nexport interface JobMatrix {\n  /**\n   * Each option you define in the matrix has a key and value. The keys you\n   * define become properties in the matrix context and you can reference the\n   * property in other areas of your workflow file. For example, if you define\n   * the key os that contains an array of operating systems, you can use the\n   * matrix.os property as the value of the runs-on keyword to create a job\n   * for each operating system.\n   */\n  readonly domain?: Record<string, JobMatrixValue[]>;\n\n  /**\n   * You can add additional configuration options to a build matrix job that\n   * already exists. For example, if you want to use a specific version of npm\n   * when the job that uses windows-latest and version 8 of node runs, you can\n   * use include to specify that additional option.\n   */\n  readonly include?: Array<Record<string, JobMatrixValue>>;\n\n  /**\n   * You can remove a specific configurations defined in the build matrix\n   * using the exclude option. Using exclude removes a job defined by the\n   * build matrix.\n   */\n  readonly exclude?: Array<Record<string, JobMatrixValue>>;\n}\n\n/**\n * Options pertaining to container environments.\n */\nexport interface ContainerOptions {\n  /**\n   * The Docker image to use as the container to run the action. The value can\n   * be the Docker Hub image name or a registry name.\n   */\n  readonly image: string;\n\n  /**\n   * f the image's container registry requires authentication to pull the\n   * image, you can use credentials to set a map of the username and password.\n   * The credentials are the same values that you would provide to the docker\n   * login command.\n   */\n  readonly credentials?: ContainerCredentials;\n\n  /**\n   * Sets a map of environment variables in the container.\n   */\n  readonly env?: Record<string, string>;\n\n  /**\n   * Sets an array of ports to expose on the container.\n   */\n  readonly ports?: number[];\n\n  /**\n   * Sets an array of volumes for the container to use. You can use volumes to\n   * share data between services or other steps in a job. You can specify\n   * named Docker volumes, anonymous Docker volumes, or bind mounts on the\n   * host.\n   *\n   * To specify a volume, you specify the source and destination path:\n   * `<source>:<destinationPath>`.\n   */\n  readonly volumes?: string[];\n\n  /**\n   * Additional Docker container resource options.\n   *\n   * @see https://docs.docker.com/engine/reference/commandline/create/#options\n   */\n  readonly options?: string[];\n}\n\n/**\n * Credentials to use to authenticate to Docker registries.\n */\nexport interface ContainerCredentials {\n  /** The username. */\n  readonly username: string;\n\n  /** The password. */\n  readonly password: string;\n}\n\n/**\n * The set of available triggers for GitHub Workflows.\n *\n * @see https://docs.github.com/en/actions/reference/events-that-trigger-workflows\n */\nexport interface Triggers {\n  //#region Scheduled events\n  /**\n   * You can schedule a workflow to run at specific UTC times using POSIX cron\n   * syntax. Scheduled workflows run on the latest commit on the default or\n   * base branch. The shortest interval you can run scheduled workflows is\n   * once every 5 minutes.\n   *\n   * @see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/crontab.html#tag_20_25_07\n   */\n  readonly schedule?: CronScheduleOptions[];\n  //#endregion\n\n  //#region Manual events\n  /**\n   * You can configure custom-defined input properties, default input values,\n   * and required inputs for the event directly in your workflow. When the\n   * workflow runs, you can access the input values in the github.event.inputs\n   * context.\n   */\n  readonly workflowDispatch?: WorkflowDispatchOptions;\n\n  /**\n   * You can use the GitHub API to trigger a webhook event called\n   * repository_dispatch when you want to trigger a workflow for activity that\n   * happens outside of GitHub.\n   */\n  readonly repositoryDispatch?: RepositoryDispatchOptions;\n  //#endregion\n\n  //#region Workflow reuse events\n  /**\n   * Can be called from another workflow\n   * @see https://docs.github.com/en/actions/learn-github-actions/reusing-workflows\n   */\n  readonly workflowCall?: WorkflowCallOptions;\n  //#endregion\n\n  //#region Webhook events\n  /**\n   * Runs your workflow anytime the branch_protection_rule event occurs.\n   */\n  readonly branchProtectionRule?: BranchProtectionRuleOptions;\n\n  /**\n   * Runs your workflow anytime the check_run event occurs.\n   */\n  readonly checkRun?: CheckRunOptions;\n\n  /**\n   * Runs your workflow anytime the check_suite event occurs.\n   */\n  readonly checkSuite?: CheckSuiteOptions;\n\n  /**\n   * Runs your workflow anytime someone creates a branch or tag, which\n   * triggers the create event.\n   */\n  readonly create?: CreateOptions;\n\n  /**\n   * Runs your workflow anytime someone deletes a branch or tag, which\n   * triggers the delete event.\n   */\n  readonly delete?: DeleteOptions;\n\n  /**\n   * Runs your workflow anytime someone creates a deployment, which triggers\n   * the deployment event. Deployments created with a commit SHA may not have\n   * a Git ref.\n   */\n  readonly deployment?: DeploymentOptions;\n\n  /**\n   * Runs your workflow anytime a third party provides a deployment status,\n   * which triggers the deployment_status event. Deployments created with a\n   * commit SHA may not have a Git ref.\n   */\n  readonly deploymentStatus?: DeploymentStatusOptions;\n\n  /**\n   * Runs your workflow anytime the discussion event occurs. More than one activity type triggers this event.\n   * @see https://docs.github.com/en/graphql/guides/using-the-graphql-api-for-discussions\n   */\n  readonly discussion?: DiscussionOptions;\n\n  /**\n   * Runs your workflow anytime the discussion_comment event occurs. More than one activity type triggers this event.\n   * @see https://docs.github.com/en/graphql/guides/using-the-graphql-api-for-discussions\n   */\n  readonly discussionComment?: DiscussionCommentOptions;\n\n  /**\n   * Runs your workflow anytime when someone forks a repository, which\n   * triggers the fork event.\n   */\n  readonly fork?: ForkOptions;\n\n  /**\n   * Runs your workflow when someone creates or updates a Wiki page, which\n   * triggers the gollum event.\n   */\n  readonly gollum?: GollumOptions;\n\n  /**\n   * Runs your workflow anytime the issue_comment event occurs.\n   */\n  readonly issueComment?: IssueCommentOptions;\n\n  /**\n   * Runs your workflow anytime the issues event occurs.\n   */\n  readonly issues?: IssuesOptions;\n\n  /**\n   * Runs your workflow anytime the label event occurs.\n   */\n  readonly label?: LabelOptions;\n\n  /**\n   * Runs your workflow when a pull request is added to a merge queue, which\n   * adds the pull request to a merge group.\n   *\n   * @stability experimental\n   */\n  readonly mergeGroup?: MergeGroupOptions;\n\n  /**\n   * Runs your workflow anytime the milestone event occurs.\n   */\n  readonly milestone?: MilestoneOptions;\n\n  /**\n   * Runs your workflow anytime someone pushes to a GitHub Pages-enabled\n   * branch, which triggers the page_build event.\n   */\n  readonly pageBuild?: PageBuildOptions;\n\n  /**\n   * Runs your workflow anytime the project event occurs.\n   */\n  readonly project?: ProjectOptions;\n\n  /**\n   * Runs your workflow anytime the project_card event occurs.\n   */\n  readonly projectCard?: ProjectCardOptions;\n\n  /**\n   * Runs your workflow anytime the project_column event occurs.\n   */\n  readonly projectColumn?: ProjectColumnOptions;\n\n  /**\n   * Runs your workflow anytime someone makes a private repository public,\n   * which triggers the public event.\n   */\n  readonly public?: PublicOptions;\n\n  /**\n   * Runs your workflow anytime the pull_request event occurs.\n   */\n  readonly pullRequest?: PullRequestOptions;\n\n  /**\n   * Runs your workflow anytime the pull_request_review event occurs.\n   */\n  readonly pullRequestReview?: PullRequestReviewOptions;\n\n  /**\n   * Runs your workflow anytime a comment on a pull request's unified diff is\n   * modified, which triggers the pull_request_review_comment event.\n   */\n  readonly pullRequestReviewComment?: PullRequestReviewCommentOptions;\n\n  /**\n   * This event runs in the context of the base of the pull request, rather\n   * than in the merge commit as the pull_request event does. This prevents\n   * executing unsafe workflow code from the head of the pull request that\n   * could alter your repository or steal any secrets you use in your workflow.\n   * This event allows you to do things like create workflows that label and\n   * comment on pull requests based on the contents of the event payload.\n   *\n   * WARNING: The `pull_request_target` event is granted read/write repository\n   * token and can access secrets, even when it is triggered from a fork.\n   * Although the workflow runs in the context of the base of the pull request,\n   * you should make sure that you do not check out, build, or run untrusted\n   * code from the pull request with this event. Additionally, any caches\n   * share the same scope as the base branch, and to help prevent cache\n   * poisoning, you should not save the cache if there is a possibility that\n   * the cache contents were altered.\n   *\n   * @see https://securitylab.github.com/research/github-actions-preventing-pwn-requests\n   */\n  readonly pullRequestTarget?: PullRequestTargetOptions;\n\n  /**\n   * Runs your workflow when someone pushes to a repository branch, which\n   * triggers the push event.\n   */\n  readonly push?: PushOptions;\n\n  /**\n   * Runs your workflow anytime a package is published or updated.\n   */\n  readonly registryPackage?: RegistryPackageOptions;\n\n  /**\n   * Runs your workflow anytime the release event occurs.\n   */\n  readonly release?: ReleaseOptions;\n\n  /**\n   * Runs your workflow anytime the status of a Git commit changes, which\n   * triggers the status event.\n   */\n  readonly status?: StatusOptions;\n\n  /**\n   * Runs your workflow anytime the watch event occurs.\n   */\n  readonly watch?: WatchOptions;\n\n  /**\n   * This event occurs when a workflow run is requested or completed, and\n   * allows you to execute a workflow based on the finished result of another\n   * workflow. A workflow run is triggered regardless of the result of the\n   * previous workflow.\n   */\n  readonly workflowRun?: WorkflowRunOptions;\n  //#endregion\n}\n\n/**\n * CRON schedule options.\n */\nexport interface CronScheduleOptions {\n  /**\n   * @see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/crontab.html#tag_20_25_07\n   */\n  readonly cron: string;\n}\n\n/**\n * Repository dispatch options.\n */\nexport interface RepositoryDispatchOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: string[];\n}\n\n/**\n * Branch Protection Rule options\n */\nexport interface BranchProtectionRuleOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"created\" | \"edited\" | \"deleted\">;\n}\n\n/**\n * Check run options.\n */\nexport interface CheckRunOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    \"create\" | \"rerequested\" | \"completed\" | \"requested_action\"\n  >;\n}\n\n/**\n * Check suite options\n */\nexport interface CheckSuiteOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"completed\" | \"requested\" | \"rerequested\">;\n}\n\n/**\n * Discussion options\n */\nexport interface DiscussionOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    | \"created\"\n    | \"edited\"\n    | \"transferred\"\n    | \"pinned\"\n    | \"unpinned\"\n    | \"labeled\"\n    | \"unlabeled\"\n    | \"locked\"\n    | \"unlocked\"\n    | \"category_changed\"\n    | \"answered\"\n    | \"unanswered\"\n  >;\n}\n\n/**\n * Discussion comment options\n */\nexport interface DiscussionCommentOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"created\" | \"edited\" | \"deleted\">;\n}\n\n/**\n * Issue comment options\n */\nexport interface IssueCommentOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"created\" | \"edited\" | \"deleted\">;\n}\n\n/**\n * Issues options\n */\nexport interface IssuesOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    | \"opened\"\n    | \"edited\"\n    | \"deleted\"\n    | \"transferred\"\n    | \"pinned\"\n    | \"unpinned\"\n    | \"closed\"\n    | \"reopened\"\n    | \"assigned\"\n    | \"unassigned\"\n    | \"labeled\"\n    | \"unlabeled\"\n    | \"locked\"\n    | \"unlocked\"\n    | \"milestoned\"\n    | \"demilestoned\"\n  >;\n}\n\n/**\n * Label options\n */\nexport interface LabelOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"created\" | \"edited\" | \"deleted\">;\n}\n\n/**\n * Merge group options.\n *\n * @stability experimental\n */\nexport interface MergeGroupOptions {\n  /**\n   * When using the merge_group events, you can configure a workflow\n   * to run on specific base branches. If not specified, all branches will\n   * trigger the workflow.\n   */\n  readonly branches?: string[];\n}\n\n/**\n * Milestone options\n */\nexport interface MilestoneOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    \"created\" | \"closed\" | \"opened\" | \"edited\" | \"deleted\"\n  >;\n}\n\n/**\n * Project options\n */\nexport interface ProjectOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    \"created\" | \"updated\" | \"closed\" | \"reopened\" | \"edited\" | \"deleted\"\n  >;\n}\n\n/**\n * Project card options\n */\nexport interface ProjectCardOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    \"created\" | \"moved\" | \"converted\" | \"edited\" | \"deleted\"\n  >;\n}\n\n/**\n * Probject column options\n */\nexport interface ProjectColumnOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"created\" | \"updated\" | \"moved\" | \"deleted\">;\n}\n\n/**\n * Pull request options\n */\nexport interface PullRequestOptions extends PushOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    | \"assigned\"\n    | \"unassigned\"\n    | \"labeled\"\n    | \"unlabeled\"\n    | \"opened\"\n    | \"edited\"\n    | \"closed\"\n    | \"reopened\"\n    | \"synchronize\"\n    | \"ready_for_review\"\n    | \"locked\"\n    | \"unlocked\"\n    | \"review_requested\"\n    | \"review_request_removed\"\n  >;\n}\n\n/**\n * Pull request review options\n */\nexport interface PullRequestReviewOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"submitted\" | \"edited\" | \"dismissed\">;\n}\n\n/**\n * Pull request review comment options\n */\nexport interface PullRequestReviewCommentOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"created\" | \"edited\" | \"deleted\">;\n}\n\n/**\n * Pull request target options.\n */\nexport interface PullRequestTargetOptions extends PushOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    | \"assigned\"\n    | \"unassigned\"\n    | \"labeled\"\n    | \"unlabeled\"\n    | \"opened\"\n    | \"edited\"\n    | \"closed\"\n    | \"reopened\"\n    | \"synchronize\"\n    | \"ready_for_review\"\n    | \"locked\"\n    | \"unlocked\"\n    | \"review_requested\"\n    | \"review_request_removed\"\n  >;\n}\n\n/**\n * Options for push-like events.\n */\nexport interface PushOptions {\n  /**\n   * When using the push, pull_request and pull_request_target events, you can configure a workflow\n   * to run on specific branches or tags. For a pull_request event, only\n   * branches and tags on the base are evaluated. If you define only tags or\n   * only branches, the workflow won't run for events affecting the undefined\n   * Git ref.\n   *\n   * @see https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet\n   */\n  readonly branches?: string[];\n\n  /**\n   * When using the push, pull_request and pull_request_target events, you can configure a workflow\n   * to run on specific branches or tags. For a pull_request event, only\n   * branches and tags on the base are evaluated. If you define only tags or\n   * only branches, the workflow won't run for events affecting the undefined\n   * Git ref.\n   *\n   * @see https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet\n   */\n  readonly tags?: string[];\n\n  /**\n   * When using the push, pull_request and pull_request_target events, you can configure a workflow\n   * to run when at least one file does not match paths-ignore or at least one\n   * modified file matches the configured paths. Path filters are not\n   * evaluated for pushes to tags.\n   *\n   * @see https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet\n   */\n  readonly paths?: string[];\n}\n\n/**\n * Registry package options\n */\nexport interface RegistryPackageOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"published\" | \"updated\">;\n}\n\n/**\n * Release options\n */\nexport interface ReleaseOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\n    | \"published\"\n    | \"unpublished\"\n    | \"created\"\n    | \"edited\"\n    | \"deleted\"\n    | \"prereleased\"\n    | \"released\"\n  >;\n}\n\n/**\n * Watch options\n */\nexport interface WatchOptions {\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"started\">;\n}\n\n/**\n * Workflow run options\n */\nexport interface WorkflowRunOptions {\n  /**\n   * Which workflow to trigger on.\n   *\n   * @defaults - any workflows\n   */\n  readonly workflows?: Array<string>;\n  /**\n   * Which activity types to trigger on.\n   *\n   * @defaults - all activity types\n   */\n  readonly types?: Array<\"completed\" | \"requested\">;\n  /**\n   * Which branches or branch-ignore to limit the trigger to.\n   *\n   * @defaults - no branch limits\n   */\n  readonly branches?: Array<string>;\n}\n\n//#region Empty Options (future-proofing the API)\n/**\n * The Workflow dispatch event accepts no options.\n */\nexport interface WorkflowDispatchOptions {}\n\n/**\n * The Workflow Call event accepts no options.\n */\nexport interface WorkflowCallOptions {}\n\n/**\n * The Create event accepts no options.\n */\nexport interface CreateOptions {}\n\n/**\n * The Delete event accepts no options.\n */\nexport interface DeleteOptions {}\n\n/**\n * The Deployment event accepts no options.\n */\nexport interface DeploymentOptions {}\n\n/**\n * The Deployment status event accepts no options.\n */\nexport interface DeploymentStatusOptions {}\n\n/**\n * The Fork event accepts no options.\n */\nexport interface ForkOptions {}\n\n/**\n * The Gollum event accepts no options.\n */\nexport interface GollumOptions {}\n\n/**\n * The Page build event accepts no options.\n */\nexport interface PageBuildOptions {}\n\n/**\n * The Public event accepts no options.\n */\nexport interface PublicOptions {}\n\n/**\n * The Status event accepts no options.\n */\nexport interface StatusOptions {}\n//#endregion\n"]}

package/lib/github/workflows.js

@@ -119,7 +119,7 @@ class GithubWorkflow extends component_1.Component {
 }
 exports.GithubWorkflow = GithubWorkflow;
 _a = JSII_RTTI_SYMBOL_1;
-GithubWorkflow[_a] = { fqn: "projen.github.GithubWorkflow", version: "0.78.9" };
+GithubWorkflow[_a] = { fqn: "projen.github.GithubWorkflow", version: "0.78.10" };
 function snakeCaseKeys(obj) {
     if (typeof obj !== "object" || obj == null) {
         return obj;

package/lib/gitlab/configuration.js

@@ -267,7 +267,7 @@ class CiConfiguration extends component_1.Component {
 }
 exports.CiConfiguration = CiConfiguration;
 _a = JSII_RTTI_SYMBOL_1;
-CiConfiguration[_a] = { fqn: "projen.gitlab.CiConfiguration", version: "0.78.9" };
+CiConfiguration[_a] = { fqn: "projen.gitlab.CiConfiguration", version: "0.78.10" };
 function snakeCaseKeys(obj, skipTopLevel = false) {
     if (typeof obj !== "object" || obj == null) {
         return obj;

package/lib/gitlab/gitlab-configuration.js

@@ -34,5 +34,5 @@ class GitlabConfiguration extends configuration_1.CiConfiguration {
 }
 exports.GitlabConfiguration = GitlabConfiguration;
 _a = JSII_RTTI_SYMBOL_1;
-GitlabConfiguration[_a] = { fqn: "projen.gitlab.GitlabConfiguration", version: "0.78.9" };
+GitlabConfiguration[_a] = { fqn: "projen.gitlab.GitlabConfiguration", version: "0.78.10" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/gitlab/nested-configuration.js

@@ -15,5 +15,5 @@ class NestedConfiguration extends configuration_1.CiConfiguration {
 }
 exports.NestedConfiguration = NestedConfiguration;
 _a = JSII_RTTI_SYMBOL_1;
-NestedConfiguration[_a] = { fqn: "projen.gitlab.NestedConfiguration", version: "0.78.9" };
+NestedConfiguration[_a] = { fqn: "projen.gitlab.NestedConfiguration", version: "0.78.10" };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmVzdGVkLWNvbmZpZ3VyYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZ2l0bGFiL25lc3RlZC1jb25maWd1cmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQ0EsbURBQWtEO0FBSWxEOztHQUVHO0FBQ0gsTUFBYSxtQkFBb0IsU0FBUSwrQkFBZTtJQUV0RCxZQUNFLE9BQWdCLEVBQ2hCLE1BQTJCLEVBQzNCLElBQVksRUFDWixPQUFnQztRQUVoQyxLQUFLLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxPQUFPLENBQUMsQ0FBQztRQUM5QixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztJQUN2QixDQUFDOztBQVZILGtEQVdDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2lDb25maWd1cmF0aW9uT3B0aW9ucyB9IGZyb20gXCIuXCI7XG5pbXBvcnQgeyBDaUNvbmZpZ3VyYXRpb24gfSBmcm9tIFwiLi9jb25maWd1cmF0aW9uXCI7XG5pbXBvcnQgeyBHaXRsYWJDb25maWd1cmF0aW9uIH0gZnJvbSBcIi4vZ2l0bGFiLWNvbmZpZ3VyYXRpb25cIjtcbmltcG9ydCB7IFByb2plY3QgfSBmcm9tIFwiLi4vcHJvamVjdFwiO1xuXG4vKipcbiAqIEEgR2l0TGFiIENJIGZvciB0ZW1wbGF0ZXMgdGhhdCBhcmUgY3JlYXRlZCBhbmQgaW5jbHVkZWQgaW4gdGhlIGAuZ2l0bGFiLWNpLnltbGAgZmlsZS5cbiAqL1xuZXhwb3J0IGNsYXNzIE5lc3RlZENvbmZpZ3VyYXRpb24gZXh0ZW5kcyBDaUNvbmZpZ3VyYXRpb24ge1xuICBwdWJsaWMgcmVhZG9ubHkgcGFyZW50OiBHaXRsYWJDb25maWd1cmF0aW9uO1xuICBjb25zdHJ1Y3RvcihcbiAgICBwcm9qZWN0OiBQcm9qZWN0LFxuICAgIHBhcmVudDogR2l0bGFiQ29uZmlndXJhdGlvbixcbiAgICBuYW1lOiBzdHJpbmcsXG4gICAgb3B0aW9ucz86IENpQ29uZmlndXJhdGlvbk9wdGlvbnNcbiAgKSB7XG4gICAgc3VwZXIocHJvamVjdCwgbmFtZSwgb3B0aW9ucyk7XG4gICAgdGhpcy5wYXJlbnQgPSBwYXJlbnQ7XG4gIH1cbn1cbiJdfQ==

package/lib/gitpod.js

@@ -241,5 +241,5 @@ class Gitpod extends component_1.Component {
 }
 exports.Gitpod = Gitpod;
 _a = JSII_RTTI_SYMBOL_1;
-Gitpod[_a] = { fqn: "projen.Gitpod", version: "0.78.9" };
+Gitpod[_a] = { fqn: "projen.Gitpod", version: "0.78.10" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gitpod.js","sourceRoot":"","sources":["../src/gitpod.ts"],"names":[],"mappings":";;;;;AAAA,2CAAwC;AAQxC,iCAAkC;AAElC;;GAEG;AACH,MAAM,WAAW,GAAG,aAAa,CAAC;AAElC;;;;;GAKG;AAEH;;GAEG;AACH,IAAY,cAyBX;AAzBD,WAAY,cAAc;IACxB;;OAEG;IACH,yCAAuB,CAAA;IACvB;;OAEG;IACH,2CAAyB,CAAA;IACzB;;OAEG;IACH,6CAA2B,CAAA;IAC3B;;OAEG;IACH,2CAAyB,CAAA;IACzB;;OAEG;IACH,yCAAuB,CAAA;IACvB;;OAEG;IACH,+CAA6B,CAAA;AAC/B,CAAC,EAzBW,cAAc,8BAAd,cAAc,QAyBzB;AAED;;GAEG;AACH,IAAY,YAiBX;AAjBD,WAAY,YAAY;IACtB;;OAEG;IACH,iCAAiB,CAAA;IACjB;;OAEG;IACH,6BAAa,CAAA;IACb;;OAEG;IACH,+BAAe,CAAA;IACf;;OAEG;IACH,6BAAa,CAAA;AACf,CAAC,EAjBW,YAAY,4BAAZ,YAAY,QAiBvB;AA2DD;;GAEG;AACH,IAAY,YAoBX;AApBD,WAAY,YAAY;IACtB;;OAEG;IACH,6CAA6B,CAAA;IAE7B;;OAEG;IACH,6CAA6B,CAAA;IAE7B;;OAEG;IACH,iCAAiB,CAAA;IAEjB;;OAEG;IACH,iCAAiB,CAAA;AACnB,CAAC,EApBW,YAAY,4BAAZ,YAAY,QAoBvB;AAED;;GAEG;AACH,IAAY,oBAUX;AAVD,WAAY,oBAAoB;IAC9B;;OAEG;IACH,yCAAiB,CAAA;IAEjB;;OAEG;IACH,2CAAmB,CAAA;AACrB,CAAC,EAVW,oBAAoB,oCAApB,oBAAoB,QAU/B;AAsGD;;GAEG;AACH,MAAa,MAAO,SAAQ,qBAAS;IAYnC,YAAY,OAAgB,EAAE,UAAyB,EAAE;QACvD,KAAK,CAAC,OAAO,CAAC,CAAC;QAVA,UAAK,GAAG,IAAI,KAAK,EAAc,CAAC;QAChC,UAAK,GAAG,IAAI,KAAK,EAAc,CAAC;QAChC,qBAAgB,GAAG,IAAI,KAAK,EAAU,CAAC;QAUtD,IAAI,CAAC,WAAW,GAAG,OAAO,EAAE,WAAW,CAAC;QAExC,IAAI,OAAO,EAAE,KAAK,EAAE;YAClB,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,KAAK,EAAE;gBAChC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;aACrB;SACF;QAED,IAAI,OAAO,EAAE,SAAS,EAAE;YACtB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;SACtC;QAED,IAAI,OAAO,EAAE,KAAK,EAAE;YAClB,IAAI,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;SACjC;QAED,IAAI,OAAO,EAAE,gBAAgB,EAAE;YAC7B,IAAI,CAAC,mBAAmB,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;SACvD;QAED,IAAI,CAAC,MAAM,GAAG;YACZ,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,EAAE;YACrC,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,EAAE;YACpC,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,MAAM,EAAE;gBACN,UAAU,EAAE,IAAI,CAAC,gBAAgB;aAClC;SACF,CAAC;QAEF,IAAI,eAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE;YACtC,GAAG,EAAE,IAAI,CAAC,MAAM;YAChB,SAAS,EAAE,IAAI;YACf,sEAAsE;YACtE,SAAS,EAAE,IAAI;SAChB,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACI,cAAc,CAAC,KAAgC;QACpD,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;SACrD;QACD,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,CAAC;IAED;;;;;;;OAOG;IACI,QAAQ,CAAC,GAAG,KAAa;QAC9B,IAAI,CAAC,KAAK,CAAC,IAAI,CACb,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACtB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,OAAO,EAAE,cAAc,IAAI,CAAC,IAAI,EAAE;SACnC,CAAC,CAAC,CACJ,CAAC;IACJ,CAAC;IAED;;;OAGG;IACI,YAAY,CAAC,MAAuB;QACzC,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC;IAC1B,CAAC;IAED;;;;;;;OAOG;IACI,aAAa,CAAC,OAAmB;QACtC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YACd,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,QAAQ,EAAE,OAAO,CAAC,QAAQ;SAC3B,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,GAAG,KAAe;QAChC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5D,CAAC;IAED;;;;;;;;;OASG;IACI,mBAAmB,CAAC,GAAG,UAAmC;QAC/D,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC;IAC5C,CAAC;IAEO,iBAAiB;QACvB,IAAI,IAAI,CAAC,WAAW,EAAE,KAAK,EAAE;YAC3B,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC;SAC/B;aAAM,IAAI,IAAI,CAAC,WAAW,EAAE,UAAU,EAAE;YACvC,OAAO;gBACL,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,UAAU;aAClC,CAAC;SACH;aAAM;YACL,OAAO,SAAS,CAAC;SAClB;IACH,CAAC;IAEO,eAAe;QACrB,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,OAAO;gBACL,SAAS,EAAE,IAAI,CAAC,SAAS;aAC1B,CAAC;SACH;aAAM;YACL,OAAO,SAAS,CAAC;SAClB;IACH,CAAC;;AAzJH,wBA0JC","sourcesContent":["import { Component } from \"./component\";\nimport {\n  IDevEnvironment,\n  DevEnvironmentOptions,\n  DevEnvironmentDockerImage,\n} from \"./dev-env\";\nimport { Project } from \"./project\";\nimport { Task } from \"./task\";\nimport { YamlFile } from \"./yaml\";\n\n/**\n * Relative path of Gitpod file to generate\n */\nconst GITPOD_FILE = \".gitpod.yml\";\n\n/**\n * https://www.gitpod.io/docs/configuration/\n * https://www.gitpod.io/docs/config-start-tasks/\n * https://www.gitpod.io/docs/prebuilds/#configure-the-github-app\n * https://www.gitpod.io/docs/vscode-extensions/\n */\n\n/**\n * Configure how the terminal should be opened relative to the previous task.\n */\nexport enum GitpodOpenMode {\n  /**\n   * Opens in the same tab group right after the previous tab\n   */\n  TAB_AFTER = \"tab-after\",\n  /**\n   * Opens in the same tab group left before the previous tab\n   */\n  TAB_BEFORE = \"tab-before\",\n  /**\n   * Splits and adds the terminal to the right\n   */\n  SPLIT_RIGHT = \"split-right\",\n  /**\n   * Splits and adds the terminal to the left\n   */\n  SPLIT_LEFT = \"split-left\",\n  /**\n   * Splits and adds the terminal to the top\n   */\n  SPLIT_TOP = \"split-top\",\n  /**\n   * Splits and adds the terminal to the bottom\n   */\n  SPLIT_BOTTOM = \"split-bottom\",\n}\n\n/**\n * Configure where in the IDE the terminal should be opened.\n */\nexport enum GitpodOpenIn {\n  /**\n   * the bottom panel (default)\n   */\n  BOTTOM = \"bottom\",\n  /**\n   * the left panel\n   */\n  LEFT = \"left\",\n  /**\n   * the right panel\n   */\n  RIGHT = \"right\",\n  /**\n   * the main editor area\n   */\n  MAIN = \"main\",\n}\n\n/**\n * Configure options for a task to be run when opening a Gitpod\n * workspace (e.g. running tests, or starting a dev server).\n *\n * Start Mode         | Execution\n * Fresh Workspace    | before && init && command\n * Restart Workspace  | before && command\n * Snapshot           | before && command\n * Prebuild           | before && init && prebuild\n */\nexport interface GitpodTask {\n  /**\n   * Required. The shell command to run\n   */\n  readonly command: string;\n\n  /**\n   * A name for this task.\n   * @default - task names are omitted when blank\n   */\n  readonly name?: string;\n\n  /**\n   * You can configure how the terminal should be opened relative to the previous task.\n   * @default GitpodOpenMode.TAB_AFTER\n   */\n  readonly openMode?: GitpodOpenMode;\n\n  /**\n   * You can configure where in the IDE the terminal should be opened\n   * @default GitpodOpenIn.BOTTOM\n   */\n  readonly openIn?: GitpodOpenIn;\n\n  /**\n   * In case you need to run something even before init, that is a requirement for both init and command,\n   * you can use the before property.\n   * @default\n   */\n  readonly before?: string;\n\n  /**\n   * The init property can be used to specify shell commands that should only be executed after a workspace\n   * was freshly cloned and needs to be initialized somehow. Such tasks are usually builds or downloading\n   * dependencies. Anything you only want to do once but not when you restart a workspace or start a snapshot.\n   * @default\n   */\n  readonly init?: string;\n\n  /**\n   * The optional prebuild command will be executed during prebuilds. It is meant to run additional long running\n   * processes that could be useful, e.g. running test suites.\n   * @default\n   */\n  readonly prebuild?: string;\n}\n\n/**\n * What to do when a service on a port is detected.\n */\nexport enum GitpodOnOpen {\n  /**\n   * Open a new browser tab\n   */\n  OPEN_BROWSER = \"open-browser\",\n\n  /**\n   * Open a preview on the right side of the IDE\n   */\n  OPEN_PREVIEW = \"open-preview\",\n\n  /**\n   * Show a notification asking the user what to do (default)\n   */\n  NOTIFY = \"notify\",\n\n  /**\n   * Do nothing.\n   */\n  IGNORE = \"ignore\",\n}\n\n/**\n * Whether the port visibility should be private or public\n */\nexport enum GitpodPortVisibility {\n  /**\n   * Allows everyone with the port URL to access the port (default)\n   */\n  PUBLIC = \"public\",\n\n  /**\n   * Only allows users with workspace access to access the port\n   */\n  PRIVATE = \"private\",\n}\n\n/**\n * Options for an exposed port on Gitpod\n */\nexport interface GitpodPort {\n  /**\n   * A port that should be exposed (forwarded) from the container.\n   *\n   * @example \"8080\"\n   */\n  readonly port?: string;\n\n  /**\n   * What to do when a service on a port is detected.\n   *\n   * @default GitpodOnOpen.NOTIFY\n   */\n  readonly onOpen?: GitpodOnOpen;\n\n  /**\n   * Whether the port visibility should be private or public.\n   *\n   * @default GitpodPortVisibility.PUBLIC\n   */\n  readonly visibility?: GitpodPortVisibility;\n}\n\n/**\n * Configure the Gitpod App for prebuilds.\n * Currently only GitHub is supported.\n * @see https://www.gitpod.io/docs/prebuilds/\n */\nexport interface GitpodPrebuilds {\n  /**\n   * Enable for the master/default branch\n   * @default true\n   */\n  readonly master?: boolean;\n\n  /**\n   * Enable for all branches in this repo\n   * @default false\n   */\n  readonly branches?: boolean;\n\n  /**\n   * Enable for pull requests coming from this repo\n   * @default true\n   */\n  readonly pullRequests?: boolean;\n\n  /**\n   * Enable for pull requests coming from forks\n   * @default false\n   */\n  readonly pullRequestsFromForks?: boolean;\n\n  /**\n   * Add a check to pull requests\n   * @default true\n   */\n  readonly addCheck?: boolean;\n\n  /**\n   * Add a \"Review in Gitpod\" button as a comment to pull requests\n   * @default false\n   */\n  readonly addComment?: boolean;\n\n  /**\n   * Add a \"Review in Gitpod\" button to the pull request's description\n   * @default false\n   */\n  readonly addBadge?: boolean;\n\n  /**\n   * Add a label once the prebuild is ready to pull requests\n   * @default false\n   */\n  readonly addLabel?: boolean;\n}\n\n/**\n * Constructor options for the Gitpod component.\n *\n * By default, Gitpod uses the 'gitpod/workspace-full' docker image.\n * @see https://github.com/gitpod-io/workspace-images/blob/master/full/Dockerfile\n *\n * By default, all tasks will be run in parallel. To run the tasks in sequence,\n * create a new task and specify the other tasks as subtasks.\n */\nexport interface GitpodOptions extends DevEnvironmentOptions {\n  /**\n   * Optional Gitpod's Github App integration for prebuilds\n   * If this is not set and Gitpod's Github App is installed, then Gitpod will apply\n   * these defaults: https://www.gitpod.io/docs/prebuilds/#configure-the-github-app\n   * @default undefined\n   */\n  readonly prebuilds?: GitpodPrebuilds;\n}\n\n/**\n * The Gitpod component which emits .gitpod.yml\n */\nexport class Gitpod extends Component implements IDevEnvironment {\n  private dockerImage: DevEnvironmentDockerImage | undefined;\n  private prebuilds: GitpodPrebuilds | undefined;\n  private readonly tasks = new Array<GitpodTask>();\n  private readonly ports = new Array<GitpodPort>();\n  private readonly vscodeExtensions = new Array<string>();\n\n  /**\n   * Direct access to the gitpod configuration (escape hatch)\n   */\n  public readonly config: any;\n\n  constructor(project: Project, options: GitpodOptions = {}) {\n    super(project);\n\n    this.dockerImage = options?.dockerImage;\n\n    if (options?.tasks) {\n      for (const task of options.tasks) {\n        this.addTasks(task);\n      }\n    }\n\n    if (options?.prebuilds) {\n      this.addPrebuilds(options.prebuilds);\n    }\n\n    if (options?.ports) {\n      this.addPorts(...options.ports);\n    }\n\n    if (options?.vscodeExtensions) {\n      this.addVscodeExtensions(...options.vscodeExtensions);\n    }\n\n    this.config = {\n      image: () => this.renderDockerImage(),\n      tasks: this.tasks,\n      github: () => this.renderPrebuilds(),\n      ports: this.ports,\n      vscode: {\n        extensions: this.vscodeExtensions,\n      },\n    };\n\n    new YamlFile(this.project, GITPOD_FILE, {\n      obj: this.config,\n      omitEmpty: true,\n      // GitPod needs to read the file from the repository in order to work.\n      committed: true,\n    });\n  }\n\n  /**\n   * Add a custom Docker image or Dockerfile for the container.\n   *\n   * @param image The Docker image\n   */\n  public addDockerImage(image: DevEnvironmentDockerImage) {\n    if (this.dockerImage) {\n      throw new Error(\"dockerImage cannot be redefined.\");\n    }\n    this.dockerImage = image;\n  }\n\n  /**\n   * Add tasks to run when gitpod starts.\n   *\n   * By default, all tasks will be run in parallel. To run tasks in sequence,\n   * create a new `Task` and specify the other tasks as subtasks.\n   *\n   * @param tasks The new tasks\n   */\n  public addTasks(...tasks: Task[]) {\n    this.tasks.push(\n      ...tasks.map((task) => ({\n        name: task.name,\n        command: `npx projen ${task.name}`,\n      }))\n    );\n  }\n\n  /**\n   * Add a prebuilds configuration for the Gitpod App\n   * @param config The configuration\n   */\n  public addPrebuilds(config: GitpodPrebuilds) {\n    this.prebuilds = config;\n  }\n\n  /**\n   * Add a task with more granular options.\n   *\n   * By default, all tasks will be run in parallel. To run tasks in sequence,\n   * create a new `Task` and set the other tasks as subtasks.\n   *\n   * @param options The task parameters\n   */\n  public addCustomTask(options: GitpodTask) {\n    this.tasks.push({\n      name: options.name,\n      command: options.command,\n      openMode: options.openMode,\n      openIn: options.openIn,\n      before: options.before,\n      init: options.init,\n      prebuild: options.prebuild,\n    });\n  }\n\n  /**\n   * Add ports that should be exposed (forwarded) from the container.\n   *\n   * @param ports The new ports\n   */\n  public addPorts(...ports: string[]) {\n    this.ports.push(...ports.map((port) => ({ port: port })));\n  }\n\n  /**\n   * Add a list of VSCode extensions that should be automatically installed\n   * in the container.\n   *\n   * These must be in the format defined in the Open VSX registry.\n   * @example 'scala-lang.scala@0.3.9:O5XmjwY5Gz+0oDZAmqneJw=='\n   * @see https://www.gitpod.io/docs/vscode-extensions/\n   *\n   * @param extensions The extension IDs\n   */\n  public addVscodeExtensions(...extensions: GitpodCodeExtensionId[]) {\n    this.vscodeExtensions.push(...extensions);\n  }\n\n  private renderDockerImage() {\n    if (this.dockerImage?.image) {\n      return this.dockerImage.image;\n    } else if (this.dockerImage?.dockerFile) {\n      return {\n        file: this.dockerImage.dockerFile,\n      };\n    } else {\n      return undefined;\n    }\n  }\n\n  private renderPrebuilds() {\n    if (this.prebuilds) {\n      return {\n        prebuilds: this.prebuilds,\n      };\n    } else {\n      return undefined;\n    }\n  }\n}\n\n/**\n * VS Code extensions as defined in the Open VSX registry\n * Example: `scala-lang.scala@0.3.9:O5XmjwY5Gz+0oDZAmqneJw==`\n */\ntype GitpodCodeExtensionId = string;\n"]}

package/lib/ignore-file.js

@@ -97,7 +97,7 @@ class IgnoreFile extends file_1.FileBase {
 }
 exports.IgnoreFile = IgnoreFile;
 _a = JSII_RTTI_SYMBOL_1;
-IgnoreFile[_a] = { fqn: "projen.IgnoreFile", version: "0.78.9" };
+IgnoreFile[_a] = { fqn: "projen.IgnoreFile", version: "0.78.10" };
 // O(n) hooray!
 function remove(arr, value) {
     const idx = arr.indexOf(value);

package/lib/ini.js

@@ -26,5 +26,5 @@ class IniFile extends object_file_1.ObjectFile {
 }
 exports.IniFile = IniFile;
 _a = JSII_RTTI_SYMBOL_1;
-IniFile[_a] = { fqn: "projen.IniFile", version: "0.78.9" };
+IniFile[_a] = { fqn: "projen.IniFile", version: "0.78.10" };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5pLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2luaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDJCQUEyQjtBQUUzQiwrQ0FBOEQ7QUFROUQ7O0dBRUc7QUFDSCxNQUFhLE9BQVEsU0FBUSx3QkFBVTtJQUNyQyxZQUFZLE9BQWdCLEVBQUUsUUFBZ0IsRUFBRSxPQUF1QjtRQUNyRSxLQUFLLENBQUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRVMsaUJBQWlCLENBQUMsUUFBbUI7UUFDN0MsTUFBTSxJQUFJLEdBQUcsS0FBSyxDQUFDLGlCQUFpQixDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQy9DLElBQUksQ0FBQyxJQUFJLEVBQUU7WUFDVCxPQUFPLFNBQVMsQ0FBQztTQUNsQjtRQUVELE9BQU87WUFDTCxHQUFHLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDNUMsRUFBRTtZQUNGLEdBQUcsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQztTQUNoQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNmLENBQUM7O0FBaEJILDBCQWlCQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIElOSSBmcm9tIFwiaW5pXCI7XG5pbXBvcnQgeyBJUmVzb2x2ZXIgfSBmcm9tIFwiLi9maWxlXCI7XG5pbXBvcnQgeyBPYmplY3RGaWxlLCBPYmplY3RGaWxlT3B0aW9ucyB9IGZyb20gXCIuL29iamVjdC1maWxlXCI7XG5pbXBvcnQgeyBQcm9qZWN0IH0gZnJvbSBcIi4vcHJvamVjdFwiO1xuXG4vKipcbiAqIE9wdGlvbnMgZm9yIGBJbmlGaWxlYC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBJbmlGaWxlT3B0aW9ucyBleHRlbmRzIE9iamVjdEZpbGVPcHRpb25zIHt9XG5cbi8qKlxuICogUmVwcmVzZW50cyBhbiBJTkkgZmlsZS5cbiAqL1xuZXhwb3J0IGNsYXNzIEluaUZpbGUgZXh0ZW5kcyBPYmplY3RGaWxlIHtcbiAgY29uc3RydWN0b3IocHJvamVjdDogUHJvamVjdCwgZmlsZVBhdGg6IHN0cmluZywgb3B0aW9uczogSW5pRmlsZU9wdGlvbnMpIHtcbiAgICBzdXBlcihwcm9qZWN0LCBmaWxlUGF0aCwgb3B0aW9ucyk7XG4gIH1cblxuICBwcm90ZWN0ZWQgc3ludGhlc2l6ZUNvbnRlbnQocmVzb2x2ZXI6IElSZXNvbHZlcik6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gICAgY29uc3QganNvbiA9IHN1cGVyLnN5bnRoZXNpemVDb250ZW50KHJlc29sdmVyKTtcbiAgICBpZiAoIWpzb24pIHtcbiAgICAgIHJldHVybiB1bmRlZmluZWQ7XG4gICAgfVxuXG4gICAgcmV0dXJuIFtcbiAgICAgIC4uLih0aGlzLm1hcmtlciA/IFtgIyAke3RoaXMubWFya2VyfWBdIDogW10pLFxuICAgICAgXCJcIixcbiAgICAgIElOSS5zdHJpbmdpZnkoSlNPTi5wYXJzZShqc29uKSksXG4gICAgXS5qb2luKFwiXFxuXCIpO1xuICB9XG59XG4iXX0=