Variable ResolveValueQueryDefinitionConst

Type declaration

• 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: any, key: string, value: any) => any,
                              space?: string | number,
                          ): string;
                          (
                              value: any,
                              replacer?: null | ((...) | (...))[],
                              space?: string | number,
                          ): string;
                      };
                      "5": (
                          __namedParameters: ParseStepOutput<string>,
                          config: QuadSerializationConfiguration,
                      ) => string;
                  };
                  processor: (
                      _results: unknown,
                      input: Partial<ParseRequiredInput<string>>,
                  ) => Promise<ParseStepOutput<string>>;
                  requiredInput: ParseRequiredInput<string>;
              }
              | {
                  dependencies: readonly ["parse"];
                  description: "Normalize the AST to flowR's AST";
                  executed: OncePerFile;
                  humanReadableName: "normalize";
                  name: "normalize";
                  printer: {
                      "0": <Input>(input: Input) => Input;
                      "2": (ast: NormalizedAst) => string;
                      "3": (ast: NormalizedAst) => string;
                      "4": (ast: NormalizedAst) => string;
                      "5": (
                          ast: NormalizedAst,
                          config: QuadSerializationConfiguration,
                      ) => string;
                  };
                  processor: (
                      results: { parse?: ParseStepOutput<string> },
                      input: Partial<NormalizeRequiredInput>,
                  ) => NormalizedAst<ParentInformation, RNode<ParentInformation>>;
                  requiredInput: NormalizeRequiredInput;
              }
              | {
                  dependencies: readonly ["normalize"];
                  description: "Construct the dataflow graph";
                  executed: OncePerFile;
                  humanReadableName: "dataflow";
                  name: "dataflow";
                  printer: {
                      "0": <Input>(input: Input) => Input;
                      "2": (df: DataflowInformation) => string;
                      "3": (df: DataflowInformation) => string;
                      "4": (df: DataflowInformation) => string;
                      "5": (
                          df: DataflowInformation,
                          config: QuadSerializationConfiguration,
                      ) => string;
                  };
                  processor: (
                      results: {
                          normalize?: NormalizedAst<ParentInformation, RNode<(...)>>;
                      },
                      input: { parser?: Parser<KnownParserType>; request?: RParseRequests },
                  ) => DataflowInformation;
                  requiredInput: {};
              },
          >,
      >,
      queryResults: BaseQueryResult,
      result: string[],
  ) => true

• Readonlyexecutor: (
      __namedParameters: BasicQueryData,
      queries: readonly ResolveValueQuery[],
  ) => ResolveValueQueryResult

• Readonlyschema: ObjectSchema<any>