Interface SupportedQuery<QueryType>

interface SupportedQuery<
    QueryType extends BaseQueryFormat["type"] = BaseQueryFormat["type"],
> {
    asciiSummarizer: (
        formatter: OutputFormatter,
        processed: 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 },
                        config: FlowrConfigOptions,
                    ) => DataflowInformation;
                    requiredInput: {};
                },
            >,
        >,
        queryResults: BaseQueryResult,
        resultStrings: string[],
    ) => boolean;
    completer?: (
        splitLine: readonly string[],
        config: FlowrConfigOptions,
    ) => string[];
    executor: QueryExecutor<QueryArgumentsWithType<QueryType>, BaseQueryResult>;
    flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
    fromLine?: (
        splitLine: readonly string[],
        config: FlowrConfigOptions,
    ) => undefined | Query | Query[];
    schema: ObjectSchema;
}