@eagleoutice/flowr 2.1.10 → 2.1.12

package/queries/catalog/search-query/search-query-executor.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeSearch = executeSearch;
+const log_1 = require("../../../util/log");
+const flowr_search_executor_1 = require("../../../search/flowr-search-executor");
+function executeSearch({ ast, dataflow }, queries) {
+    const start = Date.now();
+    if (queries.length !== 1) {
+        log_1.log.warn('Id-Map query expects only up to one query, but got', queries.length);
+    }
+    const results = [];
+    for (const query of queries) {
+        const { search } = query;
+        results.push({
+            ids: (0, flowr_search_executor_1.runSearch)(search, { normalize: ast, dataflow })
+                .map(({ node }) => node.info.id),
+            search
+        });
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        results
+    };
+}
+//# sourceMappingURL=search-query-executor.js.map

package/queries/catalog/search-query/search-query-format.d.ts

@@ -0,0 +1,72 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
+import type { FlowrSearch } from '../../../search/flowr-search-builder';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { executeSearch } from './search-query-executor';
+export interface SearchQuery extends BaseQueryFormat {
+    readonly type: 'search';
+    readonly search: FlowrSearch;
+}
+export interface SearchQueryResult extends BaseQueryResult {
+    readonly results: {
+        ids: NodeId[];
+        search: FlowrSearch;
+    }[];
+}
+export declare const SearchQueryDefinition: {
+    readonly executor: typeof executeSearch;
+    readonly asciiSummarizer: (formatter: import("../../../util/ansi").OutputFormatter, _processed: import("../../../core/steps/pipeline/pipeline").PipelineOutput<import("../../../core/steps/pipeline/pipeline").Pipeline<{
+        readonly name: "parse";
+        readonly humanReadableName: "parse with R shell";
+        readonly description: "Parse the given R code into an AST";
+        readonly processor: (_results: unknown, input: Partial<import("../../../core/steps/all/core/00-parse").ParseRequiredInput>) => Promise<import("../../../core/steps/all/core/00-parse").ParseStepOutput>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: {
+                (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+            };
+            readonly 5: ({ parsed }: import("../../../core/steps/all/core/00-parse").ParseStepOutput, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
+        };
+        readonly dependencies: readonly [];
+        readonly requiredInput: import("../../../core/steps/all/core/00-parse").ParseRequiredInput;
+    } | {
+        readonly name: "normalize";
+        readonly humanReadableName: "normalize";
+        readonly description: "Normalize the AST to flowR's AST";
+        readonly processor: (results: {
+            parse?: import("../../../core/steps/all/core/00-parse").ParseStepOutput;
+        }, input: Partial<import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/normalize-printer").normalizedAstToJson;
+            readonly 5: typeof import("../../../core/print/normalize-printer").normalizedAstToQuads;
+            readonly 3: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaid;
+            readonly 4: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+        };
+        readonly dependencies: readonly ["parse"];
+        readonly requiredInput: import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+    } | {
+        readonly humanReadableName: "dataflow";
+        readonly processor: (results: {
+            normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        }, input: {
+            request?: import("../../../r-bridge/retriever").RParseRequests;
+        }) => import("../../../dataflow/info").DataflowInformation;
+        readonly requiredInput: {};
+        readonly name: "dataflow";
+        readonly description: "Construct the dataflow graph";
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/dataflow-printer").dataflowGraphToJson;
+            readonly 5: typeof import("../../../core/print/dataflow-printer").dataflowGraphToQuads;
+            readonly 3: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaid;
+            readonly 4: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+        };
+        readonly dependencies: readonly ["normalize"];
+    }>>, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly schema: Joi.ObjectSchema<any>;
+};

package/queries/catalog/search-query/search-query-format.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchQueryDefinition = void 0;
+const ansi_1 = require("../../../util/ansi");
+const time_1 = require("../../../util/time");
+const joi_1 = __importDefault(require("joi"));
+const query_print_1 = require("../../query-print");
+const search_query_executor_1 = require("./search-query-executor");
+const flowr_search_printer_1 = require("../../../search/flowr-search-printer");
+const mermaid_1 = require("../../../util/mermaid/mermaid");
+exports.SearchQueryDefinition = {
+    executor: search_query_executor_1.executeSearch,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('search', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        for (const [, { ids, search }] of out.results.entries()) {
+            result.push(`   ╰ [query](${(0, mermaid_1.mermaidCodeToUrl)((0, flowr_search_printer_1.flowrSearchToMermaid)(search))}): {${(0, query_print_1.summarizeIdsIfTooLong)(formatter, ids)}}`);
+        }
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('search').required().description('The type of the query.'),
+        search: joi_1.default.object().required().description('The search query to execute.')
+    }).description('The id map query retrieves the id map from the normalized AST.')
+};
+//# sourceMappingURL=search-query-format.js.map

package/queries/catalog/static-slice-query/static-slice-query-executor.d.ts

@@ -1,4 +1,4 @@
 import type { StaticSliceQuery, StaticSliceQueryResult } from './static-slice-query-format';
 import type { BasicQueryData } from '../../base-query-format';
 export declare function fingerPrintOfQuery(query: StaticSliceQuery): string;
-export declare function executeStaticSliceQuery({ graph, ast }: BasicQueryData, queries: readonly StaticSliceQuery[]): StaticSliceQueryResult;
+export declare function executeStaticSliceQuery({ dataflow: { graph }, ast }: BasicQueryData, queries: readonly StaticSliceQuery[]): StaticSliceQueryResult;

package/queries/catalog/static-slice-query/static-slice-query-executor.js

@@ -10,7 +10,7 @@ const log_1 = require("../../../util/log");
 function fingerPrintOfQuery(query) {
     return JSON.stringify(query);
 }
-function executeStaticSliceQuery({ graph, ast }, queries) {
+function executeStaticSliceQuery({ dataflow: { graph }, ast }, queries) {
     const start = Date.now();
     const results = {};
     for (const query of queries) {

package/queries/query.d.ts

@@ -14,7 +14,9 @@ import type { PipelineOutput } from '../core/steps/pipeline/pipeline';
 import type { DEFAULT_DATAFLOW_PIPELINE } from '../core/steps/pipeline/default-pipelines';
 import Joi from 'joi';
 import type { LocationMapQuery } from './catalog/location-map-query/location-map-query-format';
-export type Query = CallContextQuery | DataflowQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery;
+import type { ConfigQuery } from './catalog/config-query/config-query-format';
+import type { SearchQuery } from './catalog/search-query/search-query-format';
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -33,6 +35,11 @@ export declare const SupportedQueries: {
         readonly asciiSummarizer: (formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>, queryResults: BaseQueryResult, result: string[]) => boolean;
         readonly schema: Joi.ObjectSchema<any>;
     };
+    readonly config: {
+        readonly executor: typeof import("./catalog/config-query/config-query-executor").executeConfigQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
+        readonly schema: Joi.ObjectSchema<any>;
+    };
     readonly dataflow: {
         readonly executor: typeof import("./catalog/dataflow-query/dataflow-query-executor").executeDataflowQuery;
         readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{
@@ -437,6 +444,63 @@ export declare const SupportedQueries: {
         readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
         readonly schema: Joi.ObjectSchema<any>;
     };
+    readonly search: {
+        readonly executor: typeof import("./catalog/search-query/search-query-executor").executeSearch;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{
+            readonly name: "parse";
+            readonly humanReadableName: "parse with R shell";
+            readonly description: "Parse the given R code into an AST";
+            readonly processor: (_results: unknown, input: Partial<import("../core/steps/all/core/00-parse").ParseRequiredInput>) => Promise<import("../core/steps/all/core/00-parse").ParseStepOutput>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: {
+                    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+                };
+                readonly 5: ({ parsed }: import("../core/steps/all/core/00-parse").ParseStepOutput, config: import("../util/quads").QuadSerializationConfiguration) => string;
+            };
+            readonly dependencies: readonly [];
+            readonly requiredInput: import("../core/steps/all/core/00-parse").ParseRequiredInput;
+        } | {
+            readonly name: "normalize";
+            readonly humanReadableName: "normalize";
+            readonly description: "Normalize the AST to flowR's AST";
+            readonly processor: (results: {
+                parse?: import("../core/steps/all/core/00-parse").ParseStepOutput;
+            }, input: Partial<import("../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../r-bridge/lang-4.x/ast/model/model").RNode<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/normalize-printer").normalizedAstToJson;
+                readonly 5: typeof import("../core/print/normalize-printer").normalizedAstToQuads;
+                readonly 3: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaid;
+                readonly 4: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+            };
+            readonly dependencies: readonly ["parse"];
+            readonly requiredInput: import("../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+        } | {
+            readonly humanReadableName: "dataflow";
+            readonly processor: (results: {
+                normalize?: import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+            }, input: {
+                request?: import("../r-bridge/retriever").RParseRequests;
+            }) => import("../dataflow/info").DataflowInformation;
+            readonly requiredInput: {};
+            readonly name: "dataflow";
+            readonly description: "Construct the dataflow graph";
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/dataflow-printer").dataflowGraphToJson;
+                readonly 5: typeof import("../core/print/dataflow-printer").dataflowGraphToQuads;
+                readonly 3: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaid;
+                readonly 4: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+            };
+            readonly dependencies: readonly ["normalize"];
+        }>>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly schema: Joi.ObjectSchema<any>;
+    };
 };
 export type SupportedQueryTypes = keyof typeof SupportedQueries;
 export type QueryResult<Type extends Query['type']> = ReturnType<typeof SupportedQueries[Type]['executor']>;

package/queries/query.js

@@ -22,8 +22,11 @@ const cluster_query_format_1 = require("./catalog/cluster-query/cluster-query-fo
 const dependencies_query_format_1 = require("./catalog/dependencies-query/dependencies-query-format");
 const joi_1 = __importDefault(require("joi"));
 const location_map_query_format_1 = require("./catalog/location-map-query/location-map-query-format");
+const config_query_format_1 = require("./catalog/config-query/config-query-format");
+const search_query_format_1 = require("./catalog/search-query/search-query-format");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
+    'config': config_query_format_1.ConfigQueryDefinition,
     'dataflow': dataflow_query_format_1.DataflowQueryDefinition,
     'id-map': id_map_query_format_1.IdMapQueryDefinition,
     'normalized-ast': normalized_ast_query_format_1.NormalizedAstQueryDefinition,
@@ -31,7 +34,8 @@ exports.SupportedQueries = {
     'static-slice': static_slice_query_format_1.StaticSliceQueryDefinition,
     'lineage': lineage_query_format_1.LineageQueryDefinition,
     'dependencies': dependencies_query_format_1.DependenciesQueryDefinition,
-    'location-map': location_map_query_format_1.LocationMapQueryDefinition
+    'location-map': location_map_query_format_1.LocationMapQueryDefinition,
+    'search': search_query_format_1.SearchQueryDefinition
 };
 function executeQueriesOfSameType(data, ...queries) {
     (0, assert_1.guard)(queries.length > 0, 'At least one query must be provided');

package/r-bridge/lang-4.x/ast/model/type.d.ts

@@ -204,6 +204,10 @@ export declare enum RType {
      */
     Delimiter = "RDelimiter"
 }
+export declare const ValidRTypes: Set<string>;
+export declare const ValidRTypesReverse: {
+    [k: string]: string;
+};
 /**
  * Validates, whether the given type can be used as a symbol in R
  *

package/r-bridge/lang-4.x/ast/model/type.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RType = exports.RawRType = void 0;
+exports.ValidRTypesReverse = exports.ValidRTypes = exports.RType = exports.RawRType = void 0;
 exports.isSymbol = isSymbol;
 /**
  * Token types as they are produced by the R parser.
@@ -211,6 +211,8 @@ var RType;
      */
     RType["Delimiter"] = "RDelimiter";
 })(RType || (exports.RType = RType = {}));
+exports.ValidRTypes = new Set(Object.values(RType));
+exports.ValidRTypesReverse = Object.fromEntries(Object.entries(RType).map(([k, v]) => [v, k]));
 const validSymbolTypes = new Set([
     RawRType.Symbol,
     RawRType.SymbolPackage,

package/search/flowr-search-builder.d.ts

@@ -0,0 +1,193 @@
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { FlowrSearchElement, FlowrSearchElements, FlowrSearchGetFilter } from './flowr-search';
+import type { FlowrFilterExpression } from './flowr-search-filters';
+import type { FlowrSearchGeneratorNode, GeneratorNames } from './search-executor/search-generators';
+import type { FlowrSearchTransformerNode, GetOutputOfTransformer, TransformerNames } from './search-executor/search-transformer';
+import type { SlicingCriteria } from '../slicing/criterion/parse';
+import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+type FlowrCriteriaReturn<C extends SlicingCriteria> = FlowrSearchElements<ParentInformation, C extends [] ? never : C extends [infer _] ? [
+    FlowrSearchElement<ParentInformation>
+] : FlowrSearchElement<ParentInformation>[]>;
+/**
+ * This object holds all the methods to generate search queries.
+ * For compatibility, please use the {@link Q} identifier object to access these methods.
+ */
+export declare const FlowrSearchGenerator: {
+    /**
+     * Initialize a search query with the given elements.
+     * <b>This is not intended to serialize well</b> wrt. the nodes,
+     * see {@link FlowrSearchGenerator.criterion} for a serializable alternative (passing the ids with `$id`).
+     */
+    readonly from: (from: FlowrSearchElement<ParentInformation> | FlowrSearchElement<ParentInformation>[]) => FlowrSearchBuilder<"from">;
+    /**
+     * Returns all elements (nodes/dataflow vertices) from the given data.
+     */
+    readonly all: () => FlowrSearchBuilder<"all">;
+    /**
+     * Returns all elements that match the given {@link FlowrSearchGetFilters|filters}.
+     * You may pass a negative line number to count from the back.
+     * Please note that this is currently only working for single files, it approximates over the nodes, and it is not to be used for "production".
+     */
+    readonly get: (filter: FlowrSearchGetFilter) => FlowrSearchBuilder<"get">;
+    /**
+     * Returns all elements that match the given {@link SlicingCriteria|criteria}
+     * (e.g., `criterion('2@x', '3@<-')`,
+     * to retrieve the first use of `x` in the second line and the first `<-` assignment in the third line).
+     * This will throw an error, if any criteria cannot be resolved to an id.
+     */
+    readonly criterion: <Criteria extends SlicingCriteria>(...criterion: Criteria) => FlowrSearchBuilder<"criterion", [], ParentInformation, FlowrCriteriaReturn<Criteria>>;
+    /**
+     * Short form of {@link get} with only the
+     * {@link FlowrSearchGetFilters#line|line} and {@link FlowrSearchGetFilters#column|column} filters:
+     * `get({line, column})`.
+     */
+    readonly loc: (line?: number, column?: number) => FlowrSearchBuilder<"get">;
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#name|name} and {@link FlowrSearchGetFilters#line|line} filters:
+     * `get({name, line})`.
+     */
+    readonly varInLine: (name: string, line: number) => FlowrSearchBuilder<"get">;
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#name|name} filter:
+     * `get({name})`.
+     */
+    readonly var: (name: string) => FlowrSearchBuilder<"get">;
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#id|id} filter:
+     * `get({id})`.
+     */
+    readonly id: (id: NodeId) => FlowrSearchBuilder<"get">;
+};
+/**
+ * This is the root object to use for creating searches.
+ * See the {@link FlowrSearchGenerator} for the available methods.
+ * After the query is generated,
+ * you can use what is provided by the {@link FlowrSearchBuilder} to further refine the search.
+ */
+export declare const Q: {
+    /**
+     * Initialize a search query with the given elements.
+     * <b>This is not intended to serialize well</b> wrt. the nodes,
+     * see {@link FlowrSearchGenerator.criterion} for a serializable alternative (passing the ids with `$id`).
+     */
+    readonly from: (from: FlowrSearchElement<ParentInformation> | FlowrSearchElement<ParentInformation>[]) => FlowrSearchBuilder<"from">;
+    /**
+     * Returns all elements (nodes/dataflow vertices) from the given data.
+     */
+    readonly all: () => FlowrSearchBuilder<"all">;
+    /**
+     * Returns all elements that match the given {@link FlowrSearchGetFilters|filters}.
+     * You may pass a negative line number to count from the back.
+     * Please note that this is currently only working for single files, it approximates over the nodes, and it is not to be used for "production".
+     */
+    readonly get: (filter: FlowrSearchGetFilter) => FlowrSearchBuilder<"get">;
+    /**
+     * Returns all elements that match the given {@link SlicingCriteria|criteria}
+     * (e.g., `criterion('2@x', '3@<-')`,
+     * to retrieve the first use of `x` in the second line and the first `<-` assignment in the third line).
+     * This will throw an error, if any criteria cannot be resolved to an id.
+     */
+    readonly criterion: <Criteria extends SlicingCriteria>(...criterion: Criteria) => FlowrSearchBuilder<"criterion", [], ParentInformation, FlowrCriteriaReturn<Criteria>>;
+    /**
+     * Short form of {@link get} with only the
+     * {@link FlowrSearchGetFilters#line|line} and {@link FlowrSearchGetFilters#column|column} filters:
+     * `get({line, column})`.
+     */
+    readonly loc: (line?: number, column?: number) => FlowrSearchBuilder<"get">;
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#name|name} and {@link FlowrSearchGetFilters#line|line} filters:
+     * `get({name, line})`.
+     */
+    readonly varInLine: (name: string, line: number) => FlowrSearchBuilder<"get">;
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#name|name} filter:
+     * `get({name})`.
+     */
+    readonly var: (name: string) => FlowrSearchBuilder<"get">;
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#id|id} filter:
+     * `get({id})`.
+     */
+    readonly id: (id: NodeId) => FlowrSearchBuilder<"get">;
+};
+export type FlowrSearchBuilderType<Generator extends GeneratorNames = GeneratorNames, Transformers extends TransformerNames[] = TransformerNames[], Info = ParentInformation, ElementType = FlowrSearchElements<Info, FlowrSearchElement<Info>[]>> = FlowrSearchBuilder<Generator, Transformers, Info, ElementType>;
+type GetElements<F> = F extends FlowrSearchElements<infer Info, infer Elements> ? Elements extends FlowrSearchElement<Info>[] ? Elements : never : never;
+/**
+ * The search query is a combination of a generator and a list of transformers
+ * and allows this view to pass such queries in a serialized form.
+ *
+ * @typeParam Transformers - The list of transformers that are applied to the generator's output.
+ */
+export interface FlowrSearch<Info = ParentInformation, _Generator extends GeneratorNames = GeneratorNames, _Transformers extends readonly TransformerNames[] = readonly TransformerNames[], _ElementType = FlowrSearchElements<Info, FlowrSearchElement<Info>[]>> {
+    readonly generator: FlowrSearchGeneratorNode;
+    readonly search: readonly FlowrSearchTransformerNode[];
+}
+type FlowrSearchBuilderOut<Generator extends GeneratorNames, Transformers extends TransformerNames[], Info, Transformer extends TransformerNames> = FlowrSearchBuilder<Generator, [...Transformers, Transformer], Info, GetOutputOfTransformer<Transformer>>;
+/**
+ * Allows you to construct a search query from a {@link FlowrSearchGeneratorNode}.
+ * Please use the {@link Q} object to create an object of this class!
+ * In the end, you _can_ freeze the search by calling {@link FlowrSearchBuilder#build},
+ * however, the search executors may do that for you.
+ *
+ * @see {@link FlowrSearchGenerator}
+ * @see {@link FlowrSearch}
+ * @see {@link FlowrSearchLike}
+ */
+export declare class FlowrSearchBuilder<Generator extends GeneratorNames, Transformers extends TransformerNames[] = [], Info = ParentInformation, ElementType = FlowrSearchElements<Info, FlowrSearchElement<Info>[]>> {
+    private readonly generator;
+    private readonly search;
+    constructor(generator: FlowrSearchGeneratorNode);
+    /**
+     * only returns the elements that match the given filter.
+     */
+    filter(filter: FlowrFilterExpression): FlowrSearchBuilderOut<Generator, Transformers, Info, 'filter'>;
+    /**
+     * first either returns the first element of the search or nothing, if no elements are present.
+     */
+    first(): FlowrSearchBuilderOut<Generator, Transformers, Info, 'first'>;
+    /**
+     * last either returns the last element of the search or nothing, if no elements are present.
+     */
+    last(): FlowrSearchBuilderOut<Generator, Transformers, Info, 'last'>;
+    /**
+     * index returns the element at the given index if it exists
+     */
+    index<Idx extends number>(index: Idx): FlowrSearchBuilderOut<Generator, Transformers, Info, 'index'>;
+    /**
+     * tail returns all elements of the search except the first one.
+     */
+    tail(): FlowrSearchBuilderOut<Generator, Transformers, Info, 'tail'>;
+    /**
+     * take returns the first `count` elements of the search.
+     */
+    take<Count extends number>(count: Count): FlowrSearchBuilderOut<Generator, Transformers, Info, 'take'>;
+    /**
+     * skip returns all elements of the search except the first `count` ones.
+     */
+    skip<Count extends number>(count: Count): FlowrSearchBuilderOut<Generator, Transformers, Info, 'skip'>;
+    /**
+     * select returns only the elements at the given indices.
+     */
+    select<Select extends number[]>(...select: Select): FlowrSearchBuilderOut<Generator, Transformers, Info, 'select'>;
+    /**
+     * merge combines the search results with those of another search.
+     */
+    merge<Generator2 extends GeneratorNames, Transformers2 extends TransformerNames[], OtherElementType extends FlowrSearchElements<Info, FlowrSearchElement<Info>[]>>(other: FlowrSearchBuilder<Generator2, Transformers2, Info, OtherElementType>): FlowrSearchBuilder<Generator, Transformers, Info, FlowrSearchElements<Info, [...GetElements<ElementType>, ...GetElements<OtherElementType>]>>;
+    /**
+     * Construct the final search (this may happen automatically with most search handlers).
+     *
+     * @param shouldOptimize - This may optimize the search.
+     */
+    build(shouldOptimize?: boolean): FlowrSearch<Info, Generator, Transformers, ElementType>;
+}
+/**
+ * This type summarizes all types that can be used in places in which the API expects you to provide a search query.
+ * @see {@link FlowrSearch}
+ */
+export type FlowrSearchLike = FlowrSearch | FlowrSearchBuilderType;
+export type SearchOutput<Search> = Search extends FlowrSearch ? Search : Search extends FlowrSearchBuilderType<infer Generator, infer Transformers, infer Info, infer Elements> ? FlowrSearch<Info, Generator, Transformers, Elements> : never;
+/**
+ * Freezes any accepted {@link FlowrSearchLike} into a {@link FlowrSearch}.
+ */
+export declare function getFlowrSearch<Search extends FlowrSearchLike>(search: Search, optimizeIfBuild?: boolean): SearchOutput<Search>;
+export {};