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, config: QuadSerializationConfiguration) => string);
          };
          processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
          requiredInput: ParseRequiredInput;
      } | {
          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<ParentInformation, RNode<(...)>>) => string);
              3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
              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, config: QuadSerializationConfiguration) => string);
        };
        processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
        requiredInput: ParseRequiredInput;
    } | {
        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<ParentInformation, RNode<(...)>>) => string);
            3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
            request?: RParseRequests;
        }) => DataflowInformation);
        requiredInput: {};
    }>>, queryResults: BaseQueryResult, result: string[]) => boolean)

    • • (formatter, processed, queryResults, result): boolean

      • Parameters

        • 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, config: QuadSerializationConfiguration) => string);
              };
              processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
              requiredInput: ParseRequiredInput;
          } | {
              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<ParentInformation, RNode<(...)>>) => string);
                  3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
                  request?: RParseRequests;
              }) => DataflowInformation);
              requiredInput: {};
          }>>
        • queryResults: BaseQueryResult
        • result: string[]

        Returns boolean

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

    • • (__namedParameters, queries): CallContextQueryResult

      • Multi-stage call context query resolve.

        1. Resolve all calls in the DF graph that match the respective DefaultCallContextQueryFormat#callName regex.
        2. If there is an alias attached, consider all call traces.
        3. Identify their respective call targets, if DefaultCallContextQueryFormat#callTargets is set to be non-any. This happens during the main resolution!
        4. Attach linkTo calls to the respective calls.

        Parameters

        • __namedParameters: BasicQueryData
        • queries: readonly CallContextQuery[]

        Returns CallContextQueryResult

  • Readonlyschema: 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, config: QuadSerializationConfiguration) => string);
          };
          processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
          requiredInput: ParseRequiredInput;
      } | {
          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<ParentInformation, RNode<(...)>>) => string);
              3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
              request?: RParseRequests;
          }) => DataflowInformation);
          requiredInput: {};
      }>>, queryResults: BaseQueryResult, result: string[]) => true);
      executor: ((__namedParameters: BasicQueryData, queries: readonly DataflowQuery[]) => DataflowQueryResult);
      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, config: QuadSerializationConfiguration) => string);
        };
        processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
        requiredInput: ParseRequiredInput;
    } | {
        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<ParentInformation, RNode<(...)>>) => string);
            3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
            request?: RParseRequests;
        }) => DataflowInformation);
        requiredInput: {};
    }>>, queryResults: BaseQueryResult, result: string[]) => true)

    • • (formatter, _processed, queryResults, result): true

      • Parameters

        • 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, config: QuadSerializationConfiguration) => string);
              };
              processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
              requiredInput: ParseRequiredInput;
          } | {
              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<ParentInformation, RNode<(...)>>) => string);
                  3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
                  request?: RParseRequests;
              }) => DataflowInformation);
              requiredInput: {};
          }>>
        • queryResults: BaseQueryResult
        • result: string[]

        Returns true

  • Readonlyexecutor: ((__namedParameters: BasicQueryData, queries: readonly DataflowQuery[]) => DataflowQueryResult)

    • • (__namedParameters, queries): DataflowQueryResult

      • Parameters

        • __namedParameters: BasicQueryData
        • queries: readonly DataflowQuery[]

        Returns DataflowQueryResult

  • Readonlyschema: 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, config: QuadSerializationConfiguration) => string);
          };
          processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
          requiredInput: ParseRequiredInput;
      } | {
          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<ParentInformation, RNode<(...)>>) => string);
              3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
              request?: RParseRequests;
          }) => DataflowInformation);
          requiredInput: {};
      }>>, queryResults: BaseQueryResult, result: string[]) => true);
      executor: ((__namedParameters: BasicQueryData, queries: readonly DataflowClusterQuery[]) => DataflowClusterQueryResult);
      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, config: QuadSerializationConfiguration) => string);
        };
        processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
        requiredInput: ParseRequiredInput;
    } | {
        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<ParentInformation, RNode<(...)>>) => string);
            3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
            request?: RParseRequests;
        }) => DataflowInformation);
        requiredInput: {};
    }>>, queryResults: BaseQueryResult, result: string[]) => true)

    • • (formatter, processed, queryResults, result): true

      • Parameters

        • 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, config: QuadSerializationConfiguration) => string);
              };
              processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
              requiredInput: ParseRequiredInput;
          } | {
              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<ParentInformation, RNode<(...)>>) => string);
                  3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
                  request?: RParseRequests;
              }) => DataflowInformation);
              requiredInput: {};
          }>>
        • queryResults: BaseQueryResult
        • result: string[]

        Returns true

  • Readonlyexecutor: ((__namedParameters: BasicQueryData, queries: readonly DataflowClusterQuery[]) => DataflowClusterQueryResult)

    • • (__namedParameters, queries): DataflowClusterQueryResult

      • Parameters

        • __namedParameters: BasicQueryData
        • queries: readonly DataflowClusterQuery[]

        Returns DataflowClusterQueryResult

  • Readonlyschema: 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, config: QuadSerializationConfiguration) => string);
          };
          processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
          requiredInput: ParseRequiredInput;
      } | {
          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<ParentInformation, RNode<(...)>>) => string);
              3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
              request?: RParseRequests;
          }) => DataflowInformation);
          requiredInput: {};
      }>>, queryResults: BaseQueryResult, result: string[]) => true);
      executor: ((data: BasicQueryData, queries: readonly DependenciesQuery[]) => DependenciesQueryResult);
      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, config: QuadSerializationConfiguration) => string);
        };
        processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
        requiredInput: ParseRequiredInput;
    } | {
        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<ParentInformation, RNode<(...)>>) => string);
            3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
            request?: RParseRequests;
        }) => DataflowInformation);
        requiredInput: {};
    }>>, queryResults: BaseQueryResult, result: string[]) => true)

    • • (formatter, _processed, queryResults, result): true

      • Parameters

        • 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, config: QuadSerializationConfiguration) => string);
              };
              processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
              requiredInput: ParseRequiredInput;
          } | {
              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<ParentInformation, RNode<(...)>>) => string);
                  3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
                  request?: RParseRequests;
              }) => DataflowInformation);
              requiredInput: {};
          }>>
        • queryResults: BaseQueryResult
        • result: string[]

        Returns true

  • Readonlyexecutor: ((data: BasicQueryData, queries: readonly DependenciesQuery[]) => DependenciesQueryResult)

    • • (data, queries): DependenciesQueryResult

      • Parameters

        • data: BasicQueryData
        • queries: readonly DependenciesQuery[]

        Returns DependenciesQueryResult

  • Readonlyschema: 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, config: QuadSerializationConfiguration) => string);
          };
          processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
          requiredInput: ParseRequiredInput;
      } | {
          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<ParentInformation, RNode<(...)>>) => string);
              3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
              request?: RParseRequests;
          }) => DataflowInformation);
          requiredInput: {};
      }>>, queryResults: BaseQueryResult, result: string[]) => true);
      executor: ((__namedParameters: BasicQueryData, queries: readonly IdMapQuery[]) => IdMapQueryResult);
      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, config: QuadSerializationConfiguration) => string);
        };
        processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
        requiredInput: ParseRequiredInput;
    } | {
        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<ParentInformation, RNode<(...)>>) => string);
            3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
            request?: RParseRequests;
        }) => DataflowInformation);
        requiredInput: {};
    }>>, queryResults: BaseQueryResult, result: string[]) => true)

    • • (formatter, _processed, queryResults, result): true

      • Parameters

        • 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, config: QuadSerializationConfiguration) => string);
              };
              processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
              requiredInput: ParseRequiredInput;
          } | {
              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<ParentInformation, RNode<(...)>>) => string);
                  3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
                  request?: RParseRequests;
              }) => DataflowInformation);
              requiredInput: {};
          }>>
        • queryResults: BaseQueryResult
        • result: string[]

        Returns true

  • Readonlyexecutor: ((__namedParameters: BasicQueryData, queries: readonly IdMapQuery[]) => IdMapQueryResult)

    • • (__namedParameters, queries): IdMapQueryResult

      • Parameters

        • __namedParameters: BasicQueryData
        • queries: readonly IdMapQuery[]

        Returns IdMapQueryResult

  • Readonlyschema: 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, config: QuadSerializationConfiguration) => string);
          };
          processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
          requiredInput: ParseRequiredInput;
      } | {
          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<ParentInformation, RNode<(...)>>) => string);
              3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
              request?: RParseRequests;
          }) => DataflowInformation);
          requiredInput: {};
      }>>, queryResults: BaseQueryResult, result: string[]) => true);
      executor: ((__namedParameters: BasicQueryData, queries: readonly LineageQuery[]) => LineageQueryResult);
      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, config: QuadSerializationConfiguration) => string);
        };
        processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
        requiredInput: ParseRequiredInput;
    } | {
        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<ParentInformation, RNode<(...)>>) => string);
            3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
            request?: RParseRequests;
        }) => DataflowInformation);
        requiredInput: {};
    }>>, queryResults: BaseQueryResult, result: string[]) => true)

    • • (formatter, _processed, queryResults, result): true

      • Parameters

        • 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, config: QuadSerializationConfiguration) => string);
              };
              processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
              requiredInput: ParseRequiredInput;
          } | {
              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<ParentInformation, RNode<(...)>>) => string);
                  3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
                  request?: RParseRequests;
              }) => DataflowInformation);
              requiredInput: {};
          }>>
        • queryResults: BaseQueryResult
        • result: string[]

        Returns true

  • Readonlyexecutor: ((__namedParameters: BasicQueryData, queries: readonly LineageQuery[]) => LineageQueryResult)

    • • (__namedParameters, queries): LineageQueryResult

      • Parameters

        • __namedParameters: BasicQueryData
        • queries: readonly LineageQuery[]

        Returns LineageQueryResult

  • Readonlyschema: ObjectSchema<any>

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

  • ReadonlyasciiSummarizer: ((formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean)

    • • (formatter, _processed, queryResults, result): boolean

      • Parameters

        • formatter: OutputFormatter
        • _processed: unknown
        • queryResults: BaseQueryResult
        • result: string[]

        Returns boolean

  • Readonlyexecutor: ((__namedParameters: BasicQueryData, queries: readonly LocationMapQuery[]) => LocationMapQueryResult)

    • • (__namedParameters, queries): LocationMapQueryResult

      • Parameters

        • __namedParameters: BasicQueryData
        • queries: readonly LocationMapQuery[]

        Returns LocationMapQueryResult

  • Readonlyschema: 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, config: QuadSerializationConfiguration) => string);
          };
          processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
          requiredInput: ParseRequiredInput;
      } | {
          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<ParentInformation, RNode<(...)>>) => string);
              3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
              request?: RParseRequests;
          }) => DataflowInformation);
          requiredInput: {};
      }>>, queryResults: BaseQueryResult, result: string[]) => true);
      executor: ((__namedParameters: BasicQueryData, queries: readonly NormalizedAstQuery[]) => NormalizedAstQueryResult);
      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, config: QuadSerializationConfiguration) => string);
        };
        processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
        requiredInput: ParseRequiredInput;
    } | {
        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<ParentInformation, RNode<(...)>>) => string);
            3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
            request?: RParseRequests;
        }) => DataflowInformation);
        requiredInput: {};
    }>>, queryResults: BaseQueryResult, result: string[]) => true)

    • • (formatter, _processed, queryResults, result): true

      • Parameters

        • 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, config: QuadSerializationConfiguration) => string);
              };
              processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
              requiredInput: ParseRequiredInput;
          } | {
              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<ParentInformation, RNode<(...)>>) => string);
                  3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
                  request?: RParseRequests;
              }) => DataflowInformation);
              requiredInput: {};
          }>>
        • queryResults: BaseQueryResult
        • result: string[]

        Returns true

  • Readonlyexecutor: ((__namedParameters: BasicQueryData, queries: readonly NormalizedAstQuery[]) => NormalizedAstQueryResult)

    • • (__namedParameters, queries): NormalizedAstQueryResult

      • Parameters

        • __namedParameters: BasicQueryData
        • queries: readonly NormalizedAstQuery[]

        Returns NormalizedAstQueryResult

  • Readonlyschema: 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, config: QuadSerializationConfiguration) => string);
          };
          processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
          requiredInput: ParseRequiredInput;
      } | {
          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<ParentInformation, RNode<(...)>>) => string);
              3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
              5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
              request?: RParseRequests;
          }) => DataflowInformation);
          requiredInput: {};
      }>>, queryResults: BaseQueryResult, result: string[]) => true);
      executor: ((__namedParameters: BasicQueryData, queries: readonly StaticSliceQuery[]) => StaticSliceQueryResult);
      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, config: QuadSerializationConfiguration) => string);
        };
        processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
        requiredInput: ParseRequiredInput;
    } | {
        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<ParentInformation, RNode<(...)>>) => string);
            3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
            5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
            request?: RParseRequests;
        }) => DataflowInformation);
        requiredInput: {};
    }>>, queryResults: BaseQueryResult, result: string[]) => true)

    • • (formatter, _processed, queryResults, result): true

      • Parameters

        • 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, config: QuadSerializationConfiguration) => string);
              };
              processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
              requiredInput: ParseRequiredInput;
          } | {
              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<ParentInformation, RNode<(...)>>) => string);
                  3: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  4: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>) => string);
                  5: ((ast: NormalizedAst<ParentInformation, RNode<(...)>>, 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: {
                  request?: RParseRequests;
              }) => DataflowInformation);
              requiredInput: {};
          }>>
        • queryResults: BaseQueryResult
        • result: string[]

        Returns true

  • Readonlyexecutor: ((__namedParameters: BasicQueryData, queries: readonly StaticSliceQuery[]) => StaticSliceQueryResult)

    • • (__namedParameters, queries): StaticSliceQueryResult

      • Parameters

        • __namedParameters: BasicQueryData
        • queries: readonly StaticSliceQuery[]

        Returns StaticSliceQueryResult

  • Readonlyschema: ObjectSchema<any>