Interface SliceResponseMessage

interface SliceResponseMessage {
    id: undefined | string;
    results: Omit<
        PipelineOutput<
            Pipeline<
                | {
                    dependencies: readonly [];
                    description: "Parse the given R code into an AST";
                    executed: OncePerFile;
                    humanReadableName: "parse with R shell";
                    name: "parse";
                    printer: {
                        "0": <Input>(input: Input) => Input;
                        "2": {
                            (
                                value: any,
                                replacer?: (this: any, key: string, value: any) => any,
                                space?: string | number,
                            ): string;
                            (
                                value: any,
                                replacer?: null | (string | number)[],
                                space?: string | number,
                            ): string;
                        };
                        "5": (
                            __namedParameters: ParseStepOutput<string>,
                            config: QuadSerializationConfiguration,
                        ) => string;
                    };
                    processor: (
                        _results: unknown,
                        input: Partial<ParseRequiredInput<string>>,
                    ) => Promise<ParseStepOutput<string>>;
                    requiredInput: ParseRequiredInput<string>;
                }
                | {
                    dependencies: readonly ["parse"];
                    description: "Normalize the AST to flowR's AST";
                    executed: OncePerFile;
                    humanReadableName: "normalize";
                    name: "normalize";
                    printer: {
                        "0": <Input>(input: Input) => Input;
                        "2": (ast: NormalizedAst) => string;
                        "3": (ast: NormalizedAst) => string;
                        "4": (ast: NormalizedAst) => string;
                        "5": (
                            ast: NormalizedAst,
                            config: QuadSerializationConfiguration,
                        ) => string;
                    };
                    processor: (
                        results: { parse?: ParseStepOutput<string> },
                        input: Partial<NormalizeRequiredInput>,
                    ) => NormalizedAst<ParentInformation, RNode<ParentInformation>>;
                    requiredInput: NormalizeRequiredInput;
                }
                | {
                    dependencies: readonly ["normalize"];
                    description: "Construct the dataflow graph";
                    executed: OncePerFile;
                    humanReadableName: "dataflow";
                    name: "dataflow";
                    printer: {
                        "0": <Input>(input: Input) => Input;
                        "2": (df: DataflowInformation) => string;
                        "3": (df: DataflowInformation) => string;
                        "4": (df: DataflowInformation) => string;
                        "5": (
                            df: DataflowInformation,
                            config: QuadSerializationConfiguration,
                        ) => string;
                    };
                    processor: (
                        results: {
                            normalize?: NormalizedAst<
                                ParentInformation,
                                RNode<ParentInformation>,
                            >;
                        },
                        input: { parser?: Parser<KnownParserType>; request?: RParseRequests },
                    ) => DataflowInformation;
                    requiredInput: {};
                }
                | {
                    dependencies: readonly ["dataflow"];
                    description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
                    executed: OncePerRequest;
                    humanReadableName: "static slice";
                    name: "slice";
                    printer: { "0": <Input>(input: Input) => Input };
                    processor: (
                        results: {
                            dataflow?: DataflowInformation;
                            normalize?: NormalizedAst<
                                ParentInformation,
                                RNode<ParentInformation>,
                            >;
                        },
                        input: Partial<SliceRequiredInput>,
                    ) => Readonly<SliceResult>;
                    requiredInput: SliceRequiredInput;
                }
                | {
                    dependencies: readonly ["slice"];
                    description: "Reconstruct R code from the static slice";
                    executed: OncePerRequest;
                    humanReadableName: "static code reconstruction";
                    name: "reconstruct";
                    printer: { "0": <Input>(input: Input) => Input };
                    processor: (
                        results: {
                            normalize?: NormalizedAst<
                                ParentInformation,
                                RNode<ParentInformation>,
                            >;
                            slice?: SliceResult;
                        },
                        input: Partial<ReconstructRequiredInput>,
                    ) => ReconstructionResult;
                    requiredInput: ReconstructRequiredInput;
                },
            >,
        >,
        "dataflow"
        | "parse"
        | "normalize",
    >;
    type: "response-slice";
}