Interface ShowQueryOptions<Base>

interface ShowQueryOptions<Base extends SupportedQueryTypes> {
    addOutput?: (
        result: QueryResults<Base>,
        pipeline: 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 | ((...) | (...))[],
                                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<(...)>>;
                        },
                        input: { parser?: Parser<KnownParserType>; request?: RParseRequests },
                    ) => DataflowInformation;
                    requiredInput: {};
                },
            >,
        >,
    ) => string;
    collapseQuery?: boolean;
    collapseResult?: boolean;
    showCode?: boolean;
}