Variable SupportedQueriesConst

Type Declaration

• Readonlycall-context: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          analyzer: ReadonlyFlowrAnalysisProvider,
          queryResults: BaseQueryResult,
          result: string[],
      ) => Promise<boolean>;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly CallContextQuery[],
      ) => Promise<CallContextQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        analyzer: ReadonlyFlowrAnalysisProvider,
        queryResults: BaseQueryResult,
        result: string[],
    ) => Promise<boolean>

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

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • Readonlyschema: ObjectSchema<any>

• Readonlycall-graph: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly CallGraphQuery[],
      ) => Promise<CallGraphQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly CallGraphQuery[],
    ) => Promise<CallGraphQueryResult>

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • Readonlyschema: ObjectSchema<any>

• Readonlyconfig: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: unknown,
          queryResults: BaseQueryResult,
          result: string[],
          queries: readonly Query[],
      ) => true;
      completer: (
          partialLine: readonly string[],
          _startingNewArg: boolean,
          config: FlowrConfig,
      ) => CommandCompletions;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly ConfigQuery[],
      ) => Promise<ConfigQueryResult>;
      flattenInvolvedNodes: () => never[];
      fromLine: (
          output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"config">;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: unknown,
        queryResults: BaseQueryResult,
        result: string[],
        queries: readonly Query[],
    ) => true

  • Readonlycompleter: (
        partialLine: readonly string[],
        _startingNewArg: boolean,
        config: FlowrConfig,
    ) => CommandCompletions

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly ConfigQuery[],
    ) => Promise<ConfigQueryResult>

  • ReadonlyflattenInvolvedNodes: () => never[]

  • ReadonlyfromLine: (
        output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"config">

  • Readonlyschema: ObjectSchema<any>

• Readonlycontrol-flow: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => Promise<boolean>;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly ControlFlowQuery[],
      ) => Promise<ControlFlowQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => Promise<boolean>

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly ControlFlowQuery[],
    ) => Promise<ControlFlowQueryResult>

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • Readonlyschema: ObjectSchema<any>

• Readonlydataflow: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly DataflowQuery[],
      ) => Promise<DataflowQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

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

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • Readonlyschema: ObjectSchema<any>

• Readonlydataflow-cluster: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => Promise<boolean>;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly DataflowClusterQuery[],
      ) => Promise<DataflowClusterQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => Promise<boolean>

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

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • Readonlyschema: ObjectSchema<any>

• Readonlydataflow-lens: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly DataflowLensQuery[],
      ) => Promise<DataflowLensQueryResult>;
      flattenInvolvedNodes: () => never[];
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly DataflowLensQuery[],
    ) => Promise<DataflowLensQueryResult>

  • ReadonlyflattenInvolvedNodes: () => never[]

  • Readonlyschema: ObjectSchema<any>

• Readonlydependencies: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
          queries: readonly Query[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly DependenciesQuery[],
      ) => Promise<DependenciesQueryResult>;
      flattenInvolvedNodes: (
          queryResults: BaseQueryResult,
          query: readonly Query[],
      ) => NodeId[];
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
        queries: readonly Query[],
    ) => true

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly DependenciesQuery[],
    ) => Promise<DependenciesQueryResult>

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult, query: readonly Query[]) => NodeId[]

  • Readonlyschema: ObjectSchema<any>

• Readonlydf-shape: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly DfShapeQuery[],
      ) => Promise<DfShapeQueryResult>;
      flattenInvolvedNodes: () => never[];
      fromLine: (
          _output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"df-shape">;
      jsonFormatter: (queryResults: BaseQueryResult) => object;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly DfShapeQuery[],
    ) => Promise<DfShapeQueryResult>

  • ReadonlyflattenInvolvedNodes: () => never[]

  • ReadonlyfromLine: (
        _output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"df-shape">

  • ReadonlyjsonFormatter: (queryResults: BaseQueryResult) => object

  • Readonlyschema: ObjectSchema<any>

• Readonlydoes-call: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          processed: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => Promise<boolean>;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly DoesCallQuery[],
      ) => Promise<DoesCallQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      fromLine: (
          output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"does-call">;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        processed: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => Promise<boolean>

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly DoesCallQuery[],
    ) => Promise<DoesCallQueryResult>

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • ReadonlyfromLine: (
        output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"does-call">

  • Readonlyschema: ObjectSchema<any>

• Readonlyfiles: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      completer: (
          line: readonly string[],
          startingNewArg: boolean,
          _config: FlowrConfig,
      ) => CommandCompletions;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly FilesQuery[],
      ) => Promise<FilesQueryResult>;
      flattenInvolvedNodes: (_: BaseQueryResult) => NodeId[];
      fromLine: (
          output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"files">;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

  • Readonlycompleter: (
        line: readonly string[],
        startingNewArg: boolean,
        _config: FlowrConfig,
    ) => CommandCompletions

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly FilesQuery[],
    ) => Promise<FilesQueryResult>

  • ReadonlyflattenInvolvedNodes: (_: BaseQueryResult) => NodeId[]

  • ReadonlyfromLine: (
        output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"files">

  • Readonlyschema: ObjectSchema<any>

• Readonlyhappens-before: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly HappensBeforeQuery[],
      ) => Promise<HappensBeforeQueryResult>;
      flattenInvolvedNodes: () => never[];
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly HappensBeforeQuery[],
    ) => Promise<HappensBeforeQueryResult>

  • ReadonlyflattenInvolvedNodes: () => never[]

  • Readonlyschema: ObjectSchema<any>

• Readonlyid-map: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly IdMapQuery[],
      ) => Promise<IdMapQueryResult>;
      flattenInvolvedNodes: () => never[];
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

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

  • ReadonlyflattenInvolvedNodes: () => never[]

  • Readonlyschema: ObjectSchema<any>

• Readonlyinput-sources: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => Promise<boolean>;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly InputSourcesQuery[],
      ) => Promise<InputSourcesQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      fromLine: (
          output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"input-sources">;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => Promise<boolean>

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly InputSourcesQuery[],
    ) => Promise<InputSourcesQueryResult>

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • ReadonlyfromLine: (
        output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"input-sources">

  • Readonlyschema: ObjectSchema<any>

• Readonlyinspect-exception: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          processed: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => Promise<boolean>;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly InspectExceptionQuery[],
      ) => Promise<InspectExceptionQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      fromLine: (
          _output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"inspect-exception">;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        processed: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => Promise<boolean>

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly InspectExceptionQuery[],
    ) => Promise<InspectExceptionQueryResult>

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • ReadonlyfromLine: (
        _output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"inspect-exception">

  • Readonlyschema: ObjectSchema<any>

• Readonlyinspect-higher-order: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          processed: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => Promise<boolean>;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly InspectHigherOrderQuery[],
      ) => Promise<InspectHigherOrderQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      fromLine: (
          _output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"inspect-higher-order">;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        processed: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => Promise<boolean>

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly InspectHigherOrderQuery[],
    ) => Promise<InspectHigherOrderQueryResult>

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • ReadonlyfromLine: (
        _output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"inspect-higher-order">

  • Readonlyschema: ObjectSchema<any>

• Readonlyinspect-recursion: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          processed: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => Promise<boolean>;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly InspectRecursionQuery[],
      ) => Promise<InspectRecursionQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      fromLine: (
          output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"inspect-recursion">;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        processed: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => Promise<boolean>

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly InspectRecursionQuery[],
    ) => Promise<InspectRecursionQueryResult>

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • ReadonlyfromLine: (
        output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"inspect-recursion">

  • Readonlyschema: ObjectSchema<any>

• Readonlylinter: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      completer: (
          line: readonly string[],
          startingNewArg: boolean,
          _config: FlowrConfig,
      ) => CommandCompletions;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly LinterQuery[],
      ) => Promise<LinterQueryResult>;
      flattenInvolvedNodes: (
          queryResults: BaseQueryResult,
      ) => (string & { __brand?: "node-id" } | number & { __brand?: "node-id" })[];
      fromLine: (
          output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"linter">;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

  • Readonlycompleter: (
        line: readonly string[],
        startingNewArg: boolean,
        _config: FlowrConfig,
    ) => CommandCompletions

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly LinterQuery[],
    ) => Promise<LinterQueryResult>

  • ReadonlyflattenInvolvedNodes: (
        queryResults: BaseQueryResult,
    ) => (string & { __brand?: "node-id" } | number & { __brand?: "node-id" })[]

  • ReadonlyfromLine: (
        output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"linter">

  • Readonlyschema: ObjectSchema<any>

• Readonlylocation-map: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: unknown,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly LocationMapQuery[],
      ) => Promise<LocationMapQueryResult>;
      flattenInvolvedNodes: () => never[];
      fromLine: (
          _output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"location-map">;
      schema: ObjectSchema<any>;
  }

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

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

  • ReadonlyflattenInvolvedNodes: () => never[]

  • ReadonlyfromLine: (
        _output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"location-map">

  • Readonlyschema: ObjectSchema<any>

• Readonlynormalized-ast: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly NormalizedAstQuery[],
      ) => Promise<NormalizedAstQueryResult>;
      flattenInvolvedNodes: () => never[];
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

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

  • ReadonlyflattenInvolvedNodes: () => never[]

  • Readonlyschema: ObjectSchema<any>

• Readonlyorigin: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly OriginQuery[],
      ) => Promise<OriginQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      fromLine: (
          output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"origin">;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly OriginQuery[],
    ) => Promise<OriginQueryResult>

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • ReadonlyfromLine: (
        output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"origin">

  • Readonlyschema: ObjectSchema<any>

• Readonlyproject: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly ProjectQuery[],
      ) => Promise<ProjectQueryResult>;
      flattenInvolvedNodes: () => never[];
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly ProjectQuery[],
    ) => Promise<ProjectQueryResult>

  • ReadonlyflattenInvolvedNodes: () => never[]

  • Readonlyschema: ObjectSchema<any>

• Readonlyprovenance: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => Promise<boolean>;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly ProvenanceQuery[],
      ) => Promise<ProvenanceQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      fromLine: (
          output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"provenance">;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => Promise<boolean>

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly ProvenanceQuery[],
    ) => Promise<ProvenanceQueryResult>

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • ReadonlyfromLine: (
        output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"provenance">

  • Readonlyschema: ObjectSchema<any>

• Readonlyresolve-value: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly ResolveValueQuery[],
      ) => Promise<ResolveValueQueryResult>;
      flattenInvolvedNodes: () => never[];
      fromLine: (
          output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"resolve-value">;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

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

  • ReadonlyflattenInvolvedNodes: () => never[]

  • ReadonlyfromLine: (
        output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"resolve-value">

  • Readonlyschema: ObjectSchema<any>

• Readonlysearch: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          __namedParameters: BasicQueryData,
          queries: readonly SearchQuery[],
      ) => Promise<SearchQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

  • Readonlyexecutor: (
        __namedParameters: BasicQueryData,
        queries: readonly SearchQuery[],
    ) => Promise<SearchQueryResult>

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • Readonlyschema: ObjectSchema<any>

• Readonlystatic-slice: {
      asciiSummarizer: (
          formatter: OutputFormatter,
          _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
          queryResults: BaseQueryResult,
          result: string[],
      ) => true;
      executor: (
          analyzer: BasicQueryData,
          queries: readonly StaticSliceQuery[],
      ) => Promise<StaticSliceQueryResult>;
      flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
      fromLine: (
          output: ReplOutput,
          line: readonly string[],
          _config: FlowrConfig,
      ) => ParsedQueryLine<"static-slice">;
      schema: ObjectSchema<any>;
  }

  • ReadonlyasciiSummarizer: (
        formatter: OutputFormatter,
        _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
        queryResults: BaseQueryResult,
        result: string[],
    ) => true

  • Readonlyexecutor: (
        analyzer: BasicQueryData,
        queries: readonly StaticSliceQuery[],
    ) => Promise<StaticSliceQueryResult>

  • ReadonlyflattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[]

  • ReadonlyfromLine: (
        output: ReplOutput,
        line: readonly string[],
        _config: FlowrConfig,
    ) => ParsedQueryLine<"static-slice">

  • Readonlyschema: ObjectSchema<any>