Variable SupportedQueriesConst

Type declaration

• Readonlycall-context: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => boolean;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly CallContextQuery[],
      ) => CallContextQueryResult;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        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: ..., 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: {};
                },
            >,
        >,
        queryResults: BaseQueryResult,
        result: string[],
    ) => boolean

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly CallContextQuery[],
    ) => CallContextQueryResult

  • Readonlyschema: ObjectSchema<any>

• Readonlyconfig: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _processed: unknown,
          queryResults: BaseQueryResult,
          result: string[],
      ) => boolean;
      executor: (
          _: BasicQueryData,
          queries: readonly ConfigQuery[],
      ) => ConfigQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlydataflow: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly DataflowQuery[],
      ) => DataflowQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlydataflow-cluster: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly DataflowClusterQuery[],
      ) => DataflowClusterQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlydataflow-lens: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly DataflowLensQuery[],
      ) => DataflowLensQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlydependencies: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          data: BasicQueryData,
          queries: readonly DependenciesQuery[],
      ) => DependenciesQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlyhappens-before: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly HappensBeforeQuery[],
      ) => HappensBeforeQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlyid-map: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly IdMapQuery[],
      ) => IdMapQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlylineage: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly LineageQuery[],
      ) => LineageQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlylocation-map: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _processed: unknown,
          queryResults: BaseQueryResult,
          result: string[],
      ) => boolean;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly LocationMapQuery[],
      ) => LocationMapQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlynormalized-ast: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly NormalizedAstQuery[],
      ) => NormalizedAstQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlyproject: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly ProjectQuery[],
      ) => ProjectQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlyresolve-value: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly ResolveValueQuery[],
      ) => ResolveValueQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlysearch: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly SearchQuery[],
      ) => SearchQueryResult;
      schema: ObjectSchema<any>;
  }

• Readonlystatic-slice: {
      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: ..., 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: {};
                  },
              >,
          >,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly StaticSliceQuery[],
      ) => StaticSliceQueryResult;
      schema: ObjectSchema<any>;
  }