@jttc/projen-project-types 1.0.0-beta.0 → 1.0.0-beta.10

package/lib/monorepo/interfaces/Nx.d.ts

@@ -0,0 +1,130 @@
+export interface Affected {
+    /**
+     * Default base to use for affected commands
+     * It will take the projen default base by default
+     */
+    readonly defaultBase?: string;
+}
+export type NamedInput = {
+    readonly [name: string]: string[];
+};
+export type TargetDefaultConfigurations = {
+    [name: string]: string;
+};
+export interface TargetDefaults {
+    /**
+     * Target name
+     */
+    readonly name: string;
+    /**
+     * The function that Nx will invoke when you run this target
+     */
+    readonly executor?: string;
+    readonly options?: {
+        [key: string]: string;
+    };
+    readonly outputs?: string[];
+    /**
+     * The name of a configuration to use as the default if a configuration is not provided
+     */
+    readonly defaultConfiguration?: string;
+    /**
+     * provides extra sets of values that will be merged into the options map
+     */
+    readonly configurations?: TargetDefaultConfigurations;
+    /**
+     * Whether this target runs continuously until stopped
+     * @default false
+     */
+    readonly continuous?: boolean;
+    /**
+     * Whether this target can be run in parallel with other tasks
+     * @default true
+     */
+    readonly parallelism?: boolean;
+    readonly inputs?: string[];
+    readonly dependsOn?: string[];
+    /**
+     * Specifies if the given target should be cacheable
+     */
+    readonly cache?: boolean;
+    /**
+     * List of generators to run before the target to ensure the workspace is up to date
+     */
+    readonly syncGenerators?: string[];
+}
+export interface RunnerOptions {
+    readonly accessToken?: string;
+    readonly nxCloudId?: string;
+    /**
+     * Defines whether the cache captures stderr or just stdout
+     */
+    readonly captureStderr?: boolean;
+    /**
+     * Defines the max number of targets ran in parallel
+     */
+    readonly parallel?: number;
+    /**
+     * Defines the list of targets/operations that are cached by Nx
+     */
+    readonly cacheableOperations: string[];
+    /**
+     * Defines where the local cache is stored
+     */
+    readonly cacheDirectory?: string;
+    /**
+     * Defines whether the Nx Cache should be skipped
+     */
+    readonly skipNxCache?: boolean;
+    /**
+     * Defines an encryption key to support end-to-end encryption of your cloud cache.
+     * You may also provide an environment variable with the key NX_CLOUD_ENCRYPTION_KEY
+     * that contains an encryption key as its value. The Nx Cloud task runner normalizes
+     * the key length, so any length of key is acceptable.
+     */
+    readonly encryptionKey?: string;
+}
+export interface TaskRunnerOptions {
+    /**
+     * Name of the Task Runner
+     */
+    readonly name: string;
+    /**
+     * Path to resolve the runner
+     */
+    readonly runner: string;
+    /**
+     * Default options for the runner
+     */
+    readonly options: RunnerOptions;
+}
+export interface ReleaseVersion {
+    readonly conventionalCommits: true;
+}
+export interface WorkspaceChangelog {
+    readonly createRelease: string;
+}
+export interface ReleaseChangelog {
+    readonly workspaceChangelog: WorkspaceChangelog;
+}
+export interface NxRelease {
+    readonly projects: string[];
+    readonly version: ReleaseVersion;
+    readonly changelog?: ReleaseChangelog;
+}
+export interface NxConfiguration {
+    /**
+     * Specifies the base config to exten
+     * @default nx/presets/npm.json
+     */
+    readonly extends?: string;
+    /**
+     * Default options for `nx affected`
+     */
+    readonly affected: Affected;
+    /**
+     * Named inputs used by inputs defined in targets
+     */
+    readonly namedInput: NamedInput;
+    readonly release?: NxRelease;
+}

package/lib/monorepo/interfaces/Nx.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/monorepo/interfaces/NxMonorepo.d.ts

@@ -0,0 +1,3 @@
+import { TypeScriptProjectOptions } from 'projen/lib/typescript';
+export interface NxMonorepoOptions extends TypeScriptProjectOptions {
+}

package/lib/monorepo/interfaces/NxMonorepo.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTnhNb25vcmVwby5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tb25vcmVwby9pbnRlcmZhY2VzL054TW9ub3JlcG8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFR5cGVTY3JpcHRQcm9qZWN0T3B0aW9ucyB9IGZyb20gJ3Byb2plbi9saWIvdHlwZXNjcmlwdCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTnhNb25vcmVwb09wdGlvbnMgZXh0ZW5kcyBUeXBlU2NyaXB0UHJvamVjdE9wdGlvbnMge31cbiJdfQ==

package/lib/monorepo/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Nx';
+export * from './NxMonorepo';

package/lib/monorepo/interfaces/index.js

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

package/lib/monorepo/monorepo.d.ts

@@ -0,0 +1,16 @@
+import { TypeScriptProject } from 'projen/lib/typescript';
+import { NxConfigurations } from './components/NxConfiguration';
+import { NxMonorepoOptions } from './interfaces/NxMonorepo';
+import { Commitzent } from '../components';
+/**
+ * NX Monorepo Project
+ *
+ * @pjid nx-monorepo
+ */
+export declare class NxMonorepo extends TypeScriptProject {
+    readonly commitzent?: Commitzent;
+    readonly nx: NxConfigurations;
+    constructor(options: NxMonorepoOptions);
+    addRunManyCommand(target: string, description: string): void;
+    addExecRunManyCommand(target: string): void;
+}

package/lib/monorepo/monorepo.js

@@ -0,0 +1,131 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxMonorepo = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const typescript_1 = require("projen/lib/typescript");
+const NxConfiguration_1 = require("./components/NxConfiguration");
+const publish_release_1 = require("./components/publish-release");
+const common_options_1 = require("../common/common-options");
+/**
+ * NX Monorepo Project
+ *
+ * @pjid nx-monorepo
+ */
+class NxMonorepo extends typescript_1.TypeScriptProject {
+    constructor(options) {
+        const opts = common_options_1.CommonOptionsConfig.withCommonOptionsDefaults({
+            ...options,
+        });
+        super({
+            ...opts,
+        });
+        const components = common_options_1.CommonOptionsConfig.withCommonComponents(this, opts);
+        this.commitzent = components.commitzent;
+        this.addDevDeps('nx');
+        this.addDevDeps('@nx/workspace', '@nx/devkit');
+        this.addFields({
+            private: 'true',
+            workspaces: ['packages/*'],
+        });
+        this.addGitIgnore('.nx');
+        new publish_release_1.PublishRelease(this.github, 'PublishRelease');
+        this.nx = new NxConfiguration_1.NxConfigurations(this, 'nx.json');
+        this.tasks.removeTask('release');
+        this.tasks.removeTask('build');
+        this.addRunManyCommand('build', 'Full release build for all affected projects');
+        this.tasks.removeTask('compile');
+        this.addRunManyCommand('compile', 'Only compile for all affected projects');
+        this.tasks.removeTask('test');
+        this.addRunManyCommand('test', 'Only test for all affected projects');
+        this.tasks.removeTask('test:watch');
+        this.addTask('test:watch', {
+            description: 'Only test for all affected projects',
+            steps: [
+                {
+                    exec: 'nx run-many --target=test:watch --output-style=stream --skip-nx-cache --nx-ignore-cycles --nx-bail',
+                    receiveArgs: true,
+                },
+            ],
+        });
+        this.tasks.removeTask('eslint');
+        this.addRunManyCommand('eslint', 'Run eslint for all affected projects');
+        this.tasks.removeTask('package');
+        this.addRunManyCommand('package', 'Creates the distribution package for all affected projects');
+        this.tasks.removeTask('post-compile');
+        this.addRunManyCommand('post-compile', 'Run post-compile for all affected projects');
+        this.tasks.removeTask('pre-compile');
+        this.addRunManyCommand('pre-compile', 'Run pre-compile for all affected projects');
+        this.addTask('graph', {
+            description: 'Generate dependency graph',
+            steps: [
+                {
+                    exec: 'nx graph',
+                },
+            ],
+        });
+        this.addTask('release', {
+            description: 'Prepare a release from \"main\" branch',
+            env: {
+                RELEASE: 'true',
+            },
+            steps: [
+                {
+                    exec: 'rm -fr dist',
+                },
+                {
+                    spawn: 'bump',
+                },
+                {
+                    spawn: 'build',
+                },
+                {
+                    spawn: 'unbump',
+                },
+                {
+                    exec: 'git diff --ignore-space-at-eol --exit-code',
+                },
+            ],
+        });
+        this.addExecRunManyCommand('install:ci');
+        this.addTask('run-many', {
+            description: 'Run task against multiple workspace projects',
+            steps: [
+                {
+                    exec: 'nx run-many',
+                    receiveArgs: true,
+                },
+            ],
+        });
+        this.addTask('nx', {
+            description: 'Run Nx against multiple workspace projects',
+            steps: [
+                {
+                    exec: 'nx',
+                    receiveArgs: true,
+                },
+            ],
+        });
+    }
+    addRunManyCommand(target, description) {
+        this.addTask(target, {
+            description,
+            steps: [
+                {
+                    exec: `nx run-many --target=${target} --output-style=stream --nx-bail`,
+                    receiveArgs: true,
+                },
+            ],
+        });
+    }
+    addExecRunManyCommand(target) {
+        const task = this.tasks.tryFind(target);
+        if (task) {
+            task.exec(`nx run-many --target=${target} --output-style=stream --nx-bail`);
+        }
+    }
+}
+exports.NxMonorepo = NxMonorepo;
+_a = JSII_RTTI_SYMBOL_1;
+NxMonorepo[_a] = { fqn: "@jttc/projen-project-types.NxMonorepo", version: "1.0.0-beta.10" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"monorepo.js","sourceRoot":"","sources":["../../src/monorepo/monorepo.ts"],"names":[],"mappings":"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","sourcesContent":["import { TypeScriptProject } from 'projen/lib/typescript';\nimport { NxConfigurations } from './components/NxConfiguration';\nimport { PublishRelease } from './components/publish-release';\nimport { NxMonorepoOptions } from './interfaces/NxMonorepo';\nimport { CommonOptionsConfig } from '../common/common-options';\nimport { Commitzent } from '../components';\n\n/**\n * NX Monorepo Project\n *\n * @pjid nx-monorepo\n */\nexport class NxMonorepo extends TypeScriptProject {\n  readonly commitzent?: Commitzent;\n  readonly nx: NxConfigurations;\n  constructor(options: NxMonorepoOptions) {\n    const opts = CommonOptionsConfig.withCommonOptionsDefaults({\n      ...options,\n    });\n    super({\n      ...opts,\n    });\n\n    const components = CommonOptionsConfig.withCommonComponents(this, opts);\n    this.commitzent = components.commitzent;\n\n    this.addDevDeps('nx');\n    this.addDevDeps('@nx/workspace', '@nx/devkit');\n\n    this.addFields({\n      private: 'true',\n      workspaces: ['packages/*'],\n    });\n\n    this.addGitIgnore('.nx');\n\n    new PublishRelease(this.github!, 'PublishRelease');\n\n    this.nx = new NxConfigurations(this, 'nx.json');\n\n    this.tasks.removeTask('release');\n    this.tasks.removeTask('build');\n    this.addRunManyCommand(\n      'build',\n      'Full release build for all affected projects',\n    );\n\n    this.tasks.removeTask('compile');\n    this.addRunManyCommand('compile', 'Only compile for all affected projects');\n\n    this.tasks.removeTask('test');\n    this.addRunManyCommand('test', 'Only test for all affected projects');\n\n    this.tasks.removeTask('test:watch');\n    this.addTask('test:watch', {\n      description: 'Only test for all affected projects',\n      steps: [\n        {\n          exec: 'nx run-many --target=test:watch --output-style=stream --skip-nx-cache --nx-ignore-cycles --nx-bail',\n          receiveArgs: true,\n        },\n      ],\n    });\n\n    this.tasks.removeTask('eslint');\n    this.addRunManyCommand('eslint', 'Run eslint for all affected projects');\n\n    this.tasks.removeTask('package');\n    this.addRunManyCommand(\n      'package',\n      'Creates the distribution package for all affected projects',\n    );\n\n    this.tasks.removeTask('post-compile');\n    this.addRunManyCommand(\n      'post-compile',\n      'Run post-compile for all affected projects',\n    );\n\n    this.tasks.removeTask('pre-compile');\n    this.addRunManyCommand(\n      'pre-compile',\n      'Run pre-compile for all affected projects',\n    );\n\n    this.addTask('graph', {\n      description: 'Generate dependency graph',\n      steps: [\n        {\n          exec: 'nx graph',\n        },\n      ],\n    });\n\n    this.addTask('release', {\n      description: 'Prepare a release from \\\"main\\\" branch',\n      env: {\n        RELEASE: 'true',\n      },\n      steps: [\n        {\n          exec: 'rm -fr dist',\n        },\n        {\n          spawn: 'bump',\n        },\n        {\n          spawn: 'build',\n        },\n        {\n          spawn: 'unbump',\n        },\n        {\n          exec: 'git diff --ignore-space-at-eol --exit-code',\n        },\n      ],\n    });\n\n    this.addExecRunManyCommand('install:ci');\n\n    this.addTask('run-many', {\n      description: 'Run task against multiple workspace projects',\n      steps: [\n        {\n          exec: 'nx run-many',\n          receiveArgs: true,\n        },\n      ],\n    });\n\n    this.addTask('nx', {\n      description: 'Run Nx against multiple workspace projects',\n      steps: [\n        {\n          exec: 'nx',\n          receiveArgs: true,\n        },\n      ],\n    });\n  }\n\n  addRunManyCommand(target: string, description: string) {\n    this.addTask(target, {\n      description,\n      steps: [\n        {\n          exec: `nx run-many --target=${target} --output-style=stream --nx-bail`,\n          receiveArgs: true,\n        },\n      ],\n    });\n  }\n\n  addExecRunManyCommand(target: string) {\n    const task = this.tasks.tryFind(target);\n    if (task) {\n      task.exec(\n        `nx run-many --target=${target} --output-style=stream --nx-bail`,\n      );\n    }\n  }\n}\n"]}

package/lib/terraform/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './terraform-deploy-github-workflow';
+export * from './terraform-plan-github-workflow';

package/lib/terraform/components/index.js

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

package/lib/terraform/components/terraform-deploy-github-workflow.d.ts

@@ -0,0 +1,26 @@
+import { Component, Project } from 'projen';
+/**
+ * Options for TerraformDeployGithubWorkflow component.
+ */
+export interface TerraformDeployGithubWorkflowOptions {
+    /**
+     * Terraform version to use in the workflow.
+     * @default "1.6.0"
+     */
+    readonly terraformVersion?: string;
+    /**
+     * Name of the workflow.
+     * @default "terraform-deploy"
+     */
+    readonly workflowName?: string;
+}
+/**
+ * GitHub workflow component for Terraform deployment.
+ * Creates a workflow that validates, plans, and applies Terraform changes.
+ *
+ * This component is designed for Terraform stack projects that need deployment,
+ * not for module projects that need release workflows.
+ */
+export declare class TerraformDeployGithubWorkflow extends Component {
+    constructor(project: Project, options?: TerraformDeployGithubWorkflowOptions);
+}

package/lib/terraform/components/terraform-deploy-github-workflow.js

@@ -0,0 +1,92 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerraformDeployGithubWorkflow = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+const github_1 = require("projen/lib/github");
+const workflows_model_1 = require("projen/lib/github/workflows-model");
+/**
+ * GitHub workflow component for Terraform deployment.
+ * Creates a workflow that validates, plans, and applies Terraform changes.
+ *
+ * This component is designed for Terraform stack projects that need deployment,
+ * not for module projects that need release workflows.
+ */
+class TerraformDeployGithubWorkflow extends projen_1.Component {
+    constructor(project, options = {}) {
+        super(project);
+        // Get or create GitHub component - use root project for subprojects, current project otherwise
+        const targetProject = project.parent ? project.root : project;
+        let github = targetProject.components.find((c) => c.constructor.name === 'GitHub');
+        if (!github) {
+            github = new github_1.GitHub(targetProject);
+        }
+        const workflowName = options.workflowName ?? 'terraform-deploy';
+        const terraformVersion = options.terraformVersion ?? '1.6.0';
+        // Use project outdir for subprojects, current directory for root projects
+        const workingDirectory = project.parent ? project.outdir : '.';
+        const workflow = github.addWorkflow(workflowName);
+        workflow.on({
+            push: {
+                branches: ['main'],
+                paths: ['**.tf', '**.tfvars'],
+            },
+            workflowDispatch: {},
+        });
+        workflow.addJob('terraform', {
+            name: 'Terraform',
+            runsOn: ['ubuntu-latest'],
+            env: {
+                tf_actions_working_dir: workingDirectory,
+            },
+            defaults: {
+                run: {
+                    workingDirectory: '${{ env.tf_actions_working_dir }}',
+                },
+            },
+            permissions: {
+                contents: workflows_model_1.JobPermission.READ,
+                pullRequests: workflows_model_1.JobPermission.WRITE,
+            },
+            steps: [
+                {
+                    name: 'Checkout',
+                    uses: 'actions/checkout@v4',
+                },
+                {
+                    name: 'Setup Terraform',
+                    uses: 'hashicorp/setup-terraform@v3',
+                    with: {
+                        terraform_version: terraformVersion,
+                    },
+                },
+                {
+                    name: 'Terraform Format',
+                    run: 'terraform fmt -check',
+                    continueOnError: true,
+                },
+                {
+                    name: 'Terraform Init',
+                    run: 'terraform init',
+                },
+                {
+                    name: 'Terraform Validate',
+                    run: 'terraform validate',
+                },
+                {
+                    name: 'Terraform Plan',
+                    run: 'terraform plan -input=false',
+                },
+                {
+                    name: 'Terraform Apply',
+                    run: 'terraform apply -auto-approve -input=false',
+                },
+            ],
+        });
+    }
+}
+exports.TerraformDeployGithubWorkflow = TerraformDeployGithubWorkflow;
+_a = JSII_RTTI_SYMBOL_1;
+TerraformDeployGithubWorkflow[_a] = { fqn: "@jttc/projen-project-types.TerraformDeployGithubWorkflow", version: "1.0.0-beta.10" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/terraform/components/terraform-plan-github-workflow.d.ts

@@ -0,0 +1,31 @@
+import { Component, Project } from 'projen';
+/**
+ * Options for TerraformPlanGithubWorkflow component.
+ */
+export interface TerraformPlanGithubWorkflowOptions {
+    /**
+     * Terraform version to use in the workflow.
+     * @default "1.6.0"
+     */
+    readonly terraformVersion?: string;
+    /**
+     * Name of the workflow.
+     * @default "terraform-plan"
+     */
+    readonly workflowName?: string;
+    /**
+     * Working directory for Terraform commands.
+     * @default "."
+     */
+    readonly workingDirectory?: string;
+}
+/**
+ * GitHub workflow component for Terraform plan on Pull Requests.
+ * Creates a workflow that validates, plans Terraform changes and comments results on PRs.
+ *
+ * This component is designed for Terraform stack projects to show plan results
+ * in Pull Requests without actually applying changes.
+ */
+export declare class TerraformPlanGithubWorkflow extends Component {
+    constructor(project: Project, options?: TerraformPlanGithubWorkflowOptions);
+}