@eagleoutice/flowr 1.5.2 → 2.0.1

package/cli/slicer-app.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const assert_1 = require("../util/assert");
+const log_1 = require("../util/log");
+const process_1 = require("../benchmark/summarizer/first-phase/process");
+const slice_diff_ansi_1 = require("../core/print/slice-diff-ansi");
+const json_1 = require("../util/json");
+const script_1 = require("./common/script");
+const slicer_1 = require("../benchmark/slicer");
+const print_1 = require("../benchmark/stats/print");
+const options = (0, script_1.processCommandLineArgs)('slicer', ['input', 'criterion'], {
+    subtitle: 'Slice R code based on a given slicing criterion',
+    examples: [
+        '{bold -c} {italic "12@product"} {italic test/testfiles/example.R}',
+        // why double escaped :C
+        '{bold -c} {italic "3@a"} {bold -r} {italic "a <- 3\\\\nb <- 4\\\\nprint(a)"} {bold --diff}',
+        '{bold -i} {italic example.R} {bold --stats} {bold --criterion} {italic "8:3;3:1;12@product"}',
+        '{bold --help}'
+    ]
+});
+async function getSlice() {
+    const slicer = new slicer_1.BenchmarkSlicer();
+    (0, assert_1.guard)(options.input !== undefined, 'input must be given');
+    (0, assert_1.guard)(options.criterion !== undefined, 'a slicing criterion must be given');
+    await slicer.init(options['input-is-text'] ? { request: 'text', content: options.input } : { request: 'file', content: options.input });
+    let mappedSlices = [];
+    let reconstruct = undefined;
+    const doSlicing = options.criterion.trim() !== '';
+    let slice = undefined;
+    if (doSlicing) {
+        const slices = options.criterion.split(';').map(c => c.trim());
+        try {
+            const { stats: { reconstructedCode, slicingCriteria }, slice: sliced } = await slicer.slice(...slices);
+            slice = sliced;
+            mappedSlices = slicingCriteria;
+            reconstruct = reconstructedCode;
+            if (options.output) {
+                console.log('Written reconstructed code to', options.output);
+                console.log(`Automatically selected ${reconstructedCode.autoSelected} statements`);
+                fs_1.default.writeFileSync(options.output, reconstructedCode.code);
+            }
+            else if (!options.api && !options.diff) {
+                console.log(reconstructedCode.code);
+            }
+        }
+        catch (e) {
+            log_1.log.error(`[Skipped] Error while processing ${options.input}: ${e.message} (${e.stack ?? ''})`);
+        }
+    }
+    const { stats, normalize, parse, tokenMap, dataflow } = slicer.finish();
+    const mappedCriteria = mappedSlices.map(c => `    ${c.criterion} => ${c.id} (${JSON.stringify(normalize.idMap.get(c.id)?.location)})`).join('\n');
+    log_1.log.info(`Mapped criteria:\n${mappedCriteria}`);
+    const sliceStatsAsString = (0, print_1.stats2string)(await (0, process_1.summarizeSlicerStats)(stats));
+    if (options.api) {
+        const output = {
+            tokenMap,
+            parse,
+            normalize,
+            dataflow,
+            ...(options.stats ? { stats } : {}),
+            ...(doSlicing ? { slice: mappedSlices, reconstruct } : {})
+        };
+        console.log(JSON.stringify(output, json_1.jsonReplacer));
+    }
+    else {
+        if (doSlicing && options.diff) {
+            const originalCode = options['input-is-text'] ? options.input : fs_1.default.readFileSync(options.input).toString();
+            console.log((0, slice_diff_ansi_1.sliceDiffAnsi)(slice.result, normalize, new Set(mappedSlices.map(({ id }) => id)), originalCode));
+        }
+        if (options.stats) {
+            console.log(sliceStatsAsString);
+            const filename = `${options.input}.stats`;
+            console.log(`Writing stats for ${options.input} to "${filename}"`);
+            fs_1.default.writeFileSync(filename, sliceStatsAsString);
+        }
+    }
+}
+void getSlice();
+//# sourceMappingURL=slicer-app.js.map

package/cli/statistics-app.d.ts

@@ -0,0 +1,11 @@
+export interface StatsCliOptions {
+    readonly verbose: boolean;
+    readonly help: boolean;
+    readonly limit: number | undefined;
+    readonly input: string[];
+    readonly 'dump-json': boolean;
+    readonly 'output-dir': string;
+    readonly 'no-ansi': boolean;
+    readonly parallel: number;
+    readonly features: string[];
+}

package/cli/statistics-app.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const features_1 = require("./common/features");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const log_1 = require("../util/log");
+const ansi_1 = require("../util/ansi");
+const parallel_1 = require("../util/parallel");
+const files_1 = require("../util/files");
+const json_1 = require("../util/json");
+const script_1 = require("./common/script");
+const statistics_file_1 = require("../statistics/output/statistics-file");
+const options = (0, script_1.processCommandLineArgs)('stats', [], {
+    subtitle: 'Given input files or folders, this will collect usage statistics for the given features and write them to a file',
+    examples: [
+        '{bold -i} {italic example.R} {bold -i} {italic example2.R} {bold --output-dir} {italic "output-folder/"}',
+        '{italic "folder1/"} {bold --features} {italic all} {bold --output-dir} {italic "output-folder/"}',
+        '{bold --post-process} {italic "output-folder"} {bold --features} {italic assignments}',
+        '{bold --help}'
+    ]
+});
+if (options.input.length === 0) {
+    console.error('No input files given. Nothing to do. See \'--help\' if this is an error.');
+    process.exit(0);
+}
+if (options['no-ansi']) {
+    log_1.log.info('disabling ansi colors');
+    (0, ansi_1.setFormatter)(ansi_1.voidFormatter);
+}
+const processedFeatures = (0, features_1.validateFeatures)(options.features);
+(0, statistics_file_1.initFileProvider)(options['output-dir']);
+const testRegex = /[^/]*\/test/i;
+const exampleRegex = /[^/]*\/example/i;
+function getPrefixForFile(file) {
+    if (testRegex.test(file)) {
+        return 'test-';
+    }
+    else if (exampleRegex.test(file)) {
+        return 'example-';
+    }
+    else {
+        return '';
+    }
+}
+function getSuffixForFile(base, file) {
+    const subpath = path_1.default.relative(base, file);
+    return '--' + subpath.replace(/\//g, '／');
+}
+async function collectFileArguments(verboseAdd, dumpJson, features) {
+    const files = [];
+    let counter = 0;
+    let presentSteps = 5000;
+    let skipped = 0;
+    for await (const f of (0, files_1.allRFilesFrom)(options.input)) {
+        const outputDir = path_1.default.join(options['output-dir'], `${getPrefixForFile(f.content)}${getSuffixForFile(options.input.length === 1 ? options.input[0] : '', f.content)}`);
+        const target = (0, features_1.retrieveArchiveName)(outputDir);
+        if (fs_1.default.existsSync(target)) {
+            console.log(`Archive ${target} exists. Skip.`);
+            skipped++;
+            continue;
+        }
+        files.push(['--input', f.content, '--output-dir', outputDir, '--compress', '--root-dir', options.input.length === 1 ? options.input[0] : '""', ...verboseAdd, ...features, ...dumpJson]);
+        if (++counter % presentSteps === 0) {
+            console.log(`Collected ${counter} files`);
+            if (counter >= 10 * presentSteps) {
+                presentSteps *= 5;
+            }
+        }
+    }
+    console.log(`Total: ${counter} files (${skipped} skipped with archive existing)`);
+    return files;
+}
+async function getStats() {
+    console.log(`Processing features: ${JSON.stringify(processedFeatures, json_1.jsonReplacer)}`);
+    console.log(`Using ${options.parallel} parallel executors`);
+    const verboseAdd = options.verbose ? ['--verbose'] : [];
+    const features = [...processedFeatures].flatMap(s => ['--features', s]);
+    const dumpJson = options['dump-json'] ? ['--dump-json'] : [];
+    // we do not use the limit argument to be able to pick the limit randomly
+    const args = await collectFileArguments(verboseAdd, dumpJson, features);
+    if (options.limit) {
+        console.log('Shuffle...');
+        log_1.log.info(`limiting to ${options.limit} files`);
+        // shuffle and limit
+        args.sort(() => Math.random() - 0.5);
+    }
+    console.log('Prepare Pool...');
+    const limit = options.limit ?? args.length;
+    const pool = new parallel_1.LimitedThreadPool(`${__dirname}/statistics-helper-app`, args, limit, options.parallel);
+    console.log('Run Pool...');
+    await pool.run();
+    const stats = pool.getStats();
+    console.log(`Processed ${stats.counter} files, skipped ${stats.skipped.length} files due to errors`);
+}
+void getStats();
+//# sourceMappingURL=statistics-app.js.map

package/cli/statistics-helper-app.d.ts

@@ -0,0 +1,11 @@
+export interface StatsHelperCliOptions {
+    readonly verbose: boolean;
+    readonly help: boolean;
+    readonly input: string;
+    readonly compress: boolean;
+    readonly 'dump-json': boolean;
+    readonly 'output-dir': string;
+    readonly 'root-dir': string;
+    readonly 'no-ansi': boolean;
+    readonly features: string[];
+}

package/cli/statistics-helper-app.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const features_1 = require("./common/features");
+const log_1 = require("../util/log");
+const ansi_1 = require("../util/ansi");
+const tar_1 = require("tar");
+const cfg_1 = require("../util/cfg/cfg");
+const print_1 = require("../core/print/print");
+const _00_parse_1 = require("../core/steps/all/core/00-parse");
+const _10_normalize_1 = require("../core/steps/all/core/10-normalize");
+const _20_dataflow_1 = require("../core/steps/all/core/20-dataflow");
+const json_1 = require("../util/json");
+const time_1 = require("../util/time");
+const assert_1 = require("../util/assert");
+const script_1 = require("./common/script");
+const shell_1 = require("../r-bridge/shell");
+const statistics_file_1 = require("../statistics/output/statistics-file");
+const statistics_1 = require("../statistics/statistics");
+const options = (0, script_1.processCommandLineArgs)('stats-helper', [], {
+    subtitle: 'Given a single input file, this will collect usage statistics for the given features and write them to a file',
+    examples: [
+        '{bold -i} {italic example.R} {bold -i} {italic example2.R} {bold --output-dir} {italic "output-folder/"}',
+        '{bold --help}'
+    ]
+});
+if (options['no-ansi']) {
+    log_1.log.info('disabling ansi colors');
+    (0, ansi_1.setFormatter)(ansi_1.voidFormatter);
+}
+let target = undefined;
+if (options.compress) {
+    target = (0, features_1.retrieveArchiveName)(options['output-dir']);
+    if (fs_1.default.existsSync(target)) {
+        console.log(`Archive ${target} exists. Skip.`);
+        process.exit(0);
+    }
+}
+// assume correct
+const processedFeatures = new Set(options.features);
+const shell = new shell_1.RShell();
+(0, statistics_file_1.initFileProvider)(options['output-dir']);
+function compressFolder(folder, target) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    (0, tar_1.create)({
+        gzip: true,
+        file: target,
+        portable: true,
+        preservePaths: false
+    }, [folder]).then(() => {
+        // now, remove the folder
+        fs_1.default.rmSync(folder, { recursive: true, force: true });
+    }, () => {
+        console.log(`failed to compress ${folder}`);
+    });
+}
+async function getStatsForSingleFile() {
+    await shell.obtainTmpDir();
+    const stats = await (0, statistics_1.extractUsageStatistics)(shell, () => { }, processedFeatures, (0, statistics_1.staticRequests)({ request: 'file', content: options.input }), options['root-dir']);
+    // console.warn(`skipped ${stats.meta.failedRequests.length} requests due to errors (run with logs to get more info)`)
+    if (stats.outputs.size === 1) {
+        if (options['dump-json']) {
+            const [, output] = [...stats.outputs.entries()][0];
+            const cfg = (0, cfg_1.extractCFG)(output.normalize);
+            statistics_file_1.statisticsFileProvider.append('output-json', 'parse', await (0, print_1.printStepResult)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, output.parse, 2 /* StepOutputFormat.Json */));
+            statistics_file_1.statisticsFileProvider.append('output-json', 'normalize', await (0, print_1.printStepResult)(_10_normalize_1.NORMALIZE, output.normalize, 2 /* StepOutputFormat.Json */));
+            statistics_file_1.statisticsFileProvider.append('output-json', 'dataflow', await (0, print_1.printStepResult)(_20_dataflow_1.STATIC_DATAFLOW, output.dataflow, 2 /* StepOutputFormat.Json */));
+            statistics_file_1.statisticsFileProvider.append('output-json', 'cfg', JSON.stringify(cfg, json_1.jsonReplacer));
+        }
+        statistics_file_1.statisticsFileProvider.append('meta', 'stats', JSON.stringify({ ...stats.meta, file: options.input }, json_1.jsonReplacer));
+        statistics_file_1.statisticsFileProvider.append('meta', 'features', JSON.stringify(stats.features, json_1.jsonReplacer));
+    }
+    else {
+        log_1.log.error(`expected exactly one output vs. ${stats.outputs.size}, got: ${JSON.stringify([...stats.outputs.keys()], json_1.jsonReplacer, 2)}`);
+    }
+    if (options.compress) {
+        (0, assert_1.guard)(target !== undefined, 'target must be defined given the compress option');
+        console.log(`[${(0, time_1.date2string)(new Date())}] Compressing ${options['output-dir']} to ${target}`);
+        compressFolder(options['output-dir'], target);
+    }
+    shell.close();
+}
+void getStatsForSingleFile();
+//# sourceMappingURL=statistics-helper-app.js.map

package/cli/summarizer-app.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The summarizer intends to post-process and summarize the results of
+ * * the benchmark tool, and
+ * * the statistics extraction.
+ *
+ * @module
+ */
+export interface SummarizerCliOptions {
+    verbose: boolean;
+    help: boolean;
+    'ultimate-only': boolean;
+    categorize: boolean;
+    input: string;
+    type: string;
+    output?: string;
+    graph?: boolean;
+    'project-skip': number;
+}

package/cli/summarizer-app.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * The summarizer intends to post-process and summarize the results of
+ * * the benchmark tool, and
+ * * the statistics extraction.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const summarizer_1 = require("../benchmark/summarizer/summarizer");
+const summarizer_2 = require("../statistics/summarizer/summarizer");
+const auto_detect_1 = require("../statistics/summarizer/auto-detect");
+const script_1 = require("./common/script");
+const feature_1 = require("../statistics/features/feature");
+const options = (0, script_1.processCommandLineArgs)('summarizer', ['input'], {
+    subtitle: 'Summarize and explain the results of the benchmark tool. Summarizes in two stages: first per-request, and then overall',
+    examples: [
+        '{italic benchmark.json}',
+        '{bold --help}'
+    ]
+});
+const outputBase = (options.output ?? options.input).replace(/\.json$|\/$/, '-summary');
+console.log(`Writing outputs to base ${outputBase}`);
+function getBenchmarkSummarizer() {
+    return new summarizer_1.BenchmarkSummarizer({
+        graphOutputPath: options.graph ? `${outputBase}-graph.json` : undefined,
+        inputPath: options.input,
+        intermediateOutputPath: outputBase,
+        outputPath: `${outputBase}-ultimate.json`,
+        logger: console.log
+    });
+}
+function getStatisticsSummarizer() {
+    return new summarizer_2.StatisticsSummarizer({
+        inputPath: options.input,
+        outputPath: `${outputBase}-final`,
+        intermediateOutputPath: `${outputBase}-intermediate/`,
+        projectSkip: options['project-skip'],
+        featuresToUse: feature_1.allFeatureNames,
+        logger: console.log
+    });
+}
+async function retrieveSummarizer() {
+    const type = options.type === 'auto' ? await (0, auto_detect_1.detectSummarizationType)(options.input) : options.type;
+    if (type === "benchmark" /* SummarizerType.Benchmark */) {
+        console.log('Summarizing benchmark');
+        return getBenchmarkSummarizer();
+    }
+    else if (type === "statistics" /* SummarizerType.Statistics */) {
+        console.log('Summarizing statistics');
+        return getStatisticsSummarizer();
+    }
+    else {
+        console.error('Unknown type', type, 'either give "benchmark" or "statistics"');
+        process.exit(1);
+    }
+}
+async function run() {
+    const summarizer = await retrieveSummarizer();
+    if (!options['ultimate-only']) {
+        await summarizer.preparationPhase(options.categorize);
+    }
+    await summarizer.summarizePhase();
+}
+void run();
+//# sourceMappingURL=summarizer-app.js.map

package/core/pipeline-executor.d.ts

@@ -0,0 +1,154 @@
+import type { PipelineStepName } from './steps/pipeline-step';
+import { PipelineStepStage } from './steps/pipeline-step';
+import type { Pipeline, PipelineInput, PipelineOutput, PipelinePerRequestInput, PipelineStepOutputWithName } from './steps/pipeline/pipeline';
+/**
+ * The pipeline executor allows to execute arbitrary {@link Pipeline|pipelines} in a step-by-step fashion.
+ * If you are not yet in the possession of a {@link Pipeline|pipeline}, you can use the {@link createPipeline} function
+ * to create one for yourself, based on the steps that you want to execute.
+ *
+ * Those steps are split into two phases or "stages" (which is the name that we will use in the following), represented
+ * by the {@link PipelineStepStage} type. These allow us to separate things that have to be done
+ * once per-file, e.g., actually parsing the AST, from those that we need to repeat 'once per request' (whatever this
+ * request may be). In other words, what can be cached between operations and what cannot.
+ *
+ * Furthermore, this executor follows an iterable fashion to be *as flexible as possible*
+ * (e.g., to be instrumented with measurements). So, you can use the pipeline executor like this:
+ *
+ * ```ts
+ * const stepper = new PipelineExecutor( ... )
+ * while(stepper.hasNextStep()) {
+ *     await stepper.nextStep()
+ * }
+ *
+ * stepper.switchToRequestStage()
+ *
+ * while(stepper.hasNextStep()) {
+ *     await stepper.nextStep()
+ * }
+ *
+ * const result = stepper.getResults()
+ * ```
+ *
+ * Of course, you might think, that this is rather overkill if you simply want to receive the result.
+ * And this is true. Therefore, if you do not want to perform some kind of magic in-between steps, you can use the
+ * **{@link allRemainingSteps}** function like this:
+ *
+ * ```ts
+ * const stepper = new PipelineExecutor( ... )
+ * const result = await stepper.allRemainingSteps()
+ * ```
+ *
+ * As the name suggests, you can combine this name with previous calls to {@link nextStep} to only execute the remaining
+ * steps in case, for whatever reason you only want to instrument some steps.
+ *
+ * By default, the {@link PipelineExecutor} does not offer an automatic way to repeat requests (mostly to prevent accidental errors).
+ * However, you can use the
+ * **{@link updateRequest}** function to reset the request steps and re-execute them for a new request. This allows something like the following:
+ *
+ * ```ts
+ * const stepper = new PipelineExecutor( ... )
+ * const result = await stepper.allRemainingSteps()
+ *
+ * stepper.updateRequest( ... )
+ * const result2 = await stepper.allRemainingSteps()
+ * ```
+ *
+ * **Example - Slicing With the Pipeline Executor**:
+ *
+ * Suppose, you want to... you know _slice_ a file (which was, at one point the origin of flowR), then you can
+ * either create a pipeline yourself with the respective steps, or you can use the {@link DEFAULT_SLICING_PIPELINE} (and friends).
+ * With it, slicing essentially becomes 'easy-as-pie':
+ *
+ * ```ts
+ * const slicer = new PipelineExecutor(DEFAULT_SLICING_PIPELINE, {
+ *    shell:     new RShell(),
+ *    // of course, the criterion and request given here are just examples, you can use whatever you want to slice!
+ *    criterion: ['2@b'],
+ *    request:   requestFromInput('b <- 3; x <- 5\ncat(b)'),
+ * })
+ * const result = await slicer.allRemainingSteps()
+ * ```
+ *
+ * But now, we want to slice for `x` in the first line as well! We can do that by adding:
+ *
+ * ```ts
+ * stepper.updateRequest({ criterion: ['1@x'] })
+ * const result2 = await stepper.allRemainingSteps()
+ * ```
+ *
+ * @note Even though using the pipeline executor introduces a small performance overhead, we consider
+ * it to be the baseline for performance benchmarking. It may very well be possible to squeeze out a little bit more by
+ * directly constructing the steps in the right order. However, we consider this to be negligible when compared with the time required
+ * for, for example, the dataflow analysis of larger files.
+ *
+ * @see PipelineExecutor#allRemainingSteps
+ * @see PipelineExecutor#nextStep
+ */
+export declare class PipelineExecutor<P extends Pipeline> {
+    private readonly pipeline;
+    private readonly length;
+    private input;
+    private output;
+    private currentExecutionStage;
+    private stepCounter;
+    /**
+     * Construct a new pipeline executor.
+     * The required additional input is specified by the {@link IPipelineStep#requiredInput|required input configuration} of each step in the `pipeline`.
+     *
+     * @param pipeline - The {@link Pipeline} to execute, probably created with {@link createPipeline}.
+     * @param input    - External {@link PipelineInput|configuration and input} required to execute the given pipeline.
+     */
+    constructor(pipeline: P, input: PipelineInput<P>);
+    /**
+     * Retrieve the current {@link PipelineStepStage|stage} the pipeline executor is in.
+     *
+     * @see currentExecutionStage
+     * @see switchToRequestStage
+     * @see PipelineStepStage
+     */
+    getCurrentStage(): PipelineStepStage;
+    /**
+     * Switch to the next {@link PipelineStepStage|stage} of the pipeline executor.
+     *
+     * This will fail if either a step change is currently not valid (as not all steps have been executed),
+     * or if there is no next stage (i.e., the pipeline is already completed or in the last stage).
+     *
+     * @see PipelineExecutor
+     * @see getCurrentStage
+     */
+    switchToRequestStage(): void;
+    getResults(intermediate?: false): PipelineOutput<P>;
+    getResults(intermediate: true): Partial<PipelineOutput<P>>;
+    getResults(intermediate: boolean): PipelineOutput<P>;
+    /**
+     * Returns true only if
+     * 1) there are more {@link IPipelineStep|steps} to-do for the current {@link PipelineStepStage|stage} and
+     * 2) we have not yet reached the end of the {@link Pipeline|pipeline}.
+     */
+    hasNextStep(): boolean;
+    /**
+     * Execute the next {@link IPipelineStep|step} and return the name of the {@link IPipelineStep|step} that was executed,
+     * so you can guard if the {@link IPipelineStep|step} differs from what you are interested in.
+     * Furthermore, it returns the {@link IPipelineStep|step's} result.
+     *
+     * @param expectedStepName - A safeguard if you want to retrieve the result.
+     * 												   If given, it causes the execution to fail if the next step is not the one you expect.
+     *
+     * _Without `expectedStepName`, please refrain from accessing the result, as you have no safeguards if the pipeline changes._
+     */
+    nextStep<PassedName extends PipelineStepName>(expectedStepName?: PassedName): Promise<{
+        name: typeof expectedStepName extends undefined ? PipelineStepName : PassedName;
+        result: typeof expectedStepName extends undefined ? unknown : PipelineStepOutputWithName<P, PassedName>;
+    }>;
+    private _doNextStep;
+    /**
+     * This only makes sense if you have already run a request and want to re-use the per-file results for a new one.
+     * (or if for whatever reason, you did not pass information for the pipeline with the constructor).
+     *
+     * @param newRequestData - Data for the new request
+     */
+    updateRequest(newRequestData: PipelinePerRequestInput<P>): void;
+    allRemainingSteps(canSwitchStage: false): Promise<Partial<PipelineOutput<P>>>;
+    allRemainingSteps(canSwitchStage?: true): Promise<PipelineOutput<P>>;
+    allRemainingSteps(canSwitchStage: boolean): Promise<PipelineOutput<P>>;
+}