Interface StaticSliceQueryResult

interface StaticSliceQueryResult {
    ".meta": BaseQueryMeta;
    results: Record<
        string,
        | 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: ..., key: ..., value: ...) => ...,
                                    space?: string | number,
                                ): string;
                                (
                                    value: any,
                                    replacer?: null | (...)[],
                                    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<(...)> },
                            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<(...), (...)> },
                            input: { parser?: Parser<(...)>; 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<(...), (...)>;
                            },
                            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<(...), (...)>;
                                slice?: SliceResult;
                            },
                            input: Partial<ReconstructRequiredInput>,
                        ) => ReconstructionResult;
                        requiredInput: ReconstructRequiredInput;
                    },
                >,
            >,
            "dataflow"
            | "parse"
            | "normalize",
        >
        | 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: ..., key: ..., value: ...) => ...,
                                    space?: string | number,
                                ): string;
                                (
                                    value: any,
                                    replacer?: null | (...)[],
                                    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<(...)> },
                            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<(...), (...)> },
                            input: { parser?: Parser<(...)>; 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<(...), (...)>;
                            },
                            input: Partial<SliceRequiredInput>,
                        ) => Readonly<SliceResult>;
                        requiredInput: SliceRequiredInput;
                    },
                >,
            >,
            "dataflow"
            | "parse"
            | "normalize",
        >,
    >;
}