@eagleoutice/flowr - v2.13.2
    Preparing search index...

    Variable SupportedQueriesConst

    SupportedQueries: {
        absint: {
            asciiSummarizer: (
                formatter: OutputFormatter,
                _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
                queryResults: BaseQueryResult,
                result: string[],
            ) => true;
            completer: (
                line: readonly string[],
                startingNewArg: boolean,
                _config: FlowrConfig,
            ) => CommandCompletions;
            executor: <AbsintType extends "df-shape">(
                __namedParameters: BasicQueryData,
                queries: readonly AbsintQuery<AbsintType>[],
            ) => Promise<AbsintQueryResult<AbsintType>>;
            flattenInvolvedNodes: () => never[];
            fromLine: (
                output: ReplOutput,
                line: readonly string[],
                _config: FlowrConfig,
            ) => ParsedQueryLine<"absint">;
            jsonFormatter: (queryResults: BaseQueryResult) => object;
            schema: ObjectSchema<any>;
            syntax: "@absint <inference-type> [(<criteria>)] <code | file://path>";
            title: "Abstract Interpretation Query";
        };
        "call-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>;
            title: "Call-Context Query";
        };
        "call-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>;
            title: "Call-Graph Query";
        };
        config: {
            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>;
            syntax: "@config [<path> | <glob>] | @config +<path>=<value> | @config +reset";
            title: "Config Query";
        };
        "control-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>;
            title: "Control-Flow Query";
        };
        dataflow: {
            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>;
            title: "Dataflow Query";
        };
        "dataflow-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>;
            title: "Dataflow Cluster Query";
        };
        "dataflow-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>;
            title: "Dataflow Lens Query";
        };
        dependencies: {
            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>;
            title: "Dependencies Query";
        };
        dice: {
            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 DiceQuery[],
            ) => Promise<DiceQueryResult>;
            flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
            fromLine: (
                output: ReplOutput,
                line: readonly string[],
                _config: FlowrConfig,
            ) => ParsedQueryLine<"dice">;
            schema: ObjectSchema<any>;
            syntax: "@dice (<crit>;...->crit;...)[iIcB] <code | file://path>";
            title: "Dice Query";
        };
        "does-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>;
            syntax: "@does-call (<criterion>:$<id>|\"<name>\") <code | file://path>";
            title: "Does-Call Query";
        };
        files: {
            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>;
            syntax: "@files [role:<r1>,<r2>,...] <code | file://path>";
            title: "Files Query";
        };
        "guess-dep-versions": {
            asciiSummarizer: (
                formatter: OutputFormatter,
                _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
                queryResults: BaseQueryResult,
                result: string[],
                _query: readonly Query[],
            ) => true;
            executor: (
                __namedParameters: BasicQueryData,
                queries: readonly GuessDepVersionsQuery[],
            ) => Promise<GuessDepVersionsQueryResult>;
            flattenInvolvedNodes: () => NodeId[];
            fromLine: (
                _output: ReplOutput,
                line: readonly string[],
                _config: FlowrConfig,
            ) => ParsedQueryLine<"guess-dep-versions">;
            schema: ObjectSchema<any>;
            syntax: "@guess-dep-versions [<pkg> ...] [(clean | <=YYYY.MM.DD)] [--date YYYY.MM.DD] [--max <n>] [--iterations <n>] [--disabled <letters>] [--explode [--oldest] [--limit <n>] [--prefer <pkg>=<ver>]] <code | file://path>";
            title: "Guess Dependency Versions Query";
        };
        "happens-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>;
            title: "Happens-Before Query";
        };
        "id-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>;
            title: "Id-Map Query";
        };
        "input-sources": {
            asciiSummarizer: (
                formatter: OutputFormatter,
                analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
                queryResults: BaseQueryResult,
                result: string[],
            ) => Promise<boolean>;
            completer: (
                line: readonly string[],
                startingNewArg: boolean,
                _config: FlowrConfig,
            ) => CommandCompletions;
            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>;
            syntax: "@input-sources (<criterion>) <code | file://path>";
            title: "Input Sources Query";
        };
        "inspect-exception": {
            asciiSummarizer: (
                formatter: OutputFormatter,
                processed: ReadonlyFlowrAnalysisProvider<KnownParser>,
                queryResults: BaseQueryResult,
                result: string[],
            ) => Promise<boolean>;
            completer: (
                line: readonly string[],
                startingNewArg: boolean,
                _config: FlowrConfig,
            ) => CommandCompletions;
            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>;
            syntax: "@inspect-exception [(<crit>;...)] <code | file://path>";
            title: "Inspect Exceptions of Functions Query";
        };
        "inspect-higher-order": {
            asciiSummarizer: (
                formatter: OutputFormatter,
                processed: ReadonlyFlowrAnalysisProvider<KnownParser>,
                queryResults: BaseQueryResult,
                result: string[],
            ) => Promise<boolean>;
            completer: (
                line: readonly string[],
                startingNewArg: boolean,
                _config: FlowrConfig,
            ) => CommandCompletions;
            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>;
            syntax: "@inspect-higher-order [(<crit>;...)] <code | file://path>";
            title: "Inspect Higher-Order Functions Query";
        };
        "inspect-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>;
            syntax: "@inspect-recursion [(<crit>;...)] <code | file://path>";
            title: "Inspect Recursive Functions Query";
        };
        linter: {
            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,
                _queries: readonly Query[],
                certainty: LintingResultCertainty | undefined,
            ) => (string & { __brand?: "node-id" } | number & { __brand?: "node-id" })[];
            fromLine: (
                output: ReplOutput,
                line: readonly string[],
                _config: FlowrConfig,
            ) => ParsedQueryLine<"linter">;
            schema: ObjectSchema<any>;
            syntax: "@linter [rules:<r1>,<r2>,...] [format:<fmt>] <code | file://path>";
            title: "Linter Query";
        };
        "location-map": {
            asciiSummarizer: (
                formatter: OutputFormatter,
                _analyzer: unknown,
                queryResults: BaseQueryResult,
                result: string[],
            ) => true;
            completer: (
                line: readonly string[],
                startingNewArg: boolean,
                _config: FlowrConfig,
            ) => CommandCompletions;
            executor: (
                __namedParameters: BasicQueryData,
                queries: readonly LocationMapQuery[],
            ) => Promise<LocationMapQueryResult>;
            flattenInvolvedNodes: () => never[];
            fromLine: (
                _output: ReplOutput,
                line: readonly string[],
                _config: FlowrConfig,
            ) => ParsedQueryLine<"location-map">;
            schema: ObjectSchema<any>;
            syntax: "@location-map [(<crit>;...)] <code | file://path>";
            title: "Location Map Query";
        };
        "normalized-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>;
            title: "Normalized AST Query";
        };
        origin: {
            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 OriginQuery[],
            ) => Promise<OriginQueryResult>;
            flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
            fromLine: (
                output: ReplOutput,
                line: readonly string[],
                _config: FlowrConfig,
            ) => ParsedQueryLine<"origin">;
            schema: ObjectSchema<any>;
            syntax: "@origin (<criterion>) <code | file://path>";
            title: "Origin Query";
        };
        project: {
            asciiSummarizer: (
                formatter: OutputFormatter,
                analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
                queryResults: BaseQueryResult,
                result: string[],
            ) => true;
            executor: (
                __namedParameters: BasicQueryData,
                queries: readonly ProjectQuery[],
            ) => Promise<ProjectQueryResult>;
            flattenInvolvedNodes: () => never[];
            schema: ObjectSchema<any>;
            title: "Project Query";
        };
        provenance: {
            asciiSummarizer: (
                formatter: OutputFormatter,
                analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
                queryResults: BaseQueryResult,
                result: string[],
            ) => Promise<boolean>;
            completer: (
                line: readonly string[],
                startingNewArg: boolean,
                _config: FlowrConfig,
            ) => CommandCompletions;
            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>;
            syntax: "@provenance (<criterion>)[f] <code | file://path>";
            title: "Provenance Query";
        };
        "resolve-value": {
            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 ResolveValueQuery[],
            ) => Promise<ResolveValueQueryResult>;
            flattenInvolvedNodes: () => never[];
            fromLine: (
                output: ReplOutput,
                line: readonly string[],
                _config: FlowrConfig,
            ) => ParsedQueryLine<"resolve-value">;
            schema: ObjectSchema<any>;
            syntax: "@resolve-value (<crit>;...) <code | file://path>";
            title: "Resolve Value Query";
        };
        search: {
            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>;
            title: "Search Query";
        };
        signature: {
            asciiSummarizer: (
                formatter: OutputFormatter,
                _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
                queryResults: BaseQueryResult,
                result: string[],
                _query: readonly Query[],
            ) => true;
            completer: (
                line: readonly string[],
                startingNewArg: boolean,
            ) => CommandCompletions;
            executor: (
                __namedParameters: BasicQueryData,
                queries: readonly SignatureQuery[],
            ) => Promise<SignatureQueryResult>;
            flattenInvolvedNodes: () => NodeId[];
            fromLine: (
                output: ReplOutput,
                line: readonly string[],
                _config: FlowrConfig,
            ) => ParsedQueryLine<"signature">;
            schema: ObjectSchema<any>;
            syntax: "@signature [<pkg>[@<version>]] [<pkg>::<fn> | <fn>] [--param <name>[,...]] [--required <n>] [--cg] [--help]";
            title: "Signature Query";
        };
        "static-slice": {
            asciiSummarizer: (
                formatter: OutputFormatter,
                _analyzer: ReadonlyFlowrAnalysisProvider<KnownParser>,
                queryResults: BaseQueryResult,
                result: string[],
            ) => true;
            completer: (
                line: readonly string[],
                startingNewArg: boolean,
                _config: FlowrConfig,
            ) => CommandCompletions;
            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>;
            syntax: "@static-slice (<crit>;...)[fiIcB] <code | file://path>";
            title: "Static Slice Query";
        };
    } = ...

    Type Declaration

    Settings

    Member Visibility