@eagleoutice/flowr 2.9.9 → 2.9.11

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

@@ -1,22 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getArgumentWithId = getArgumentWithId;
+exports.RArgument = void 0;
+const type_1 = require("../type");
 const r_function_call_1 = require("./r-function-call");
 /**
- * Retrieve the argument with the given id from the list of arguments.
+ * Helper for working with {@link RArgument} AST nodes.
  */
-function getArgumentWithId(args, id) {
-    if (id === undefined) {
-        return undefined;
-    }
-    for (const arg of args) {
-        if (arg === r_function_call_1.EmptyArgument) {
-            continue;
+exports.RArgument = {
+    name: 'RArgument',
+    /**
+     * Type guard for {@link RArgument} nodes.
+     * @see {@link RArgument.isUnnamed} - to check whether an argument is unnamed
+     */
+    is(node) {
+        return node?.type === type_1.RType.Argument;
+    },
+    /**
+     * Type guard for named arguments, i.e. arguments with a name.
+     */
+    isNamed(node) {
+        return exports.RArgument.is(node) && node.name !== undefined;
+    },
+    /**
+     * Type guard for unnamed arguments, i.e. arguments without a name.
+     */
+    isUnnamed(node) {
+        return exports.RArgument.is(node) && node.name === undefined && node.value !== undefined;
+    },
+    /**
+     * Type guard for arguments with a value, i.e. arguments that are not just placeholders without a value.
+     */
+    isWithValue(node) {
+        return exports.RArgument.is(node) && node.value !== undefined;
+    },
+    getWithId(args, id) {
+        if (id === undefined) {
+            return undefined;
         }
-        if (arg.info.id === id) {
-            return arg;
+        for (const arg of args) {
+            if (arg === r_function_call_1.EmptyArgument) {
+                continue;
+            }
+            if (arg.info.id === id) {
+                return arg;
+            }
         }
+        return undefined;
+    },
+    /**
+     * Retrieve the value of the argument with the given id from the list of arguments.
+     */
+    getValue(args, id) {
+        return exports.RArgument.getWithId(args, id)?.value;
     }
-    return undefined;
-}
+};
 //# sourceMappingURL=r-argument.js.map

package/r-bridge/lang-4.x/ast/model/nodes/r-binary-op.d.ts

@@ -1,5 +1,6 @@
 import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
+import type { OperatorInformationValue } from '../operators';
 /**
  * Operators like `+`, `==`, `&&`, etc.
  */
@@ -9,3 +10,17 @@ export interface RBinaryOp<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     lhs: RNode<Info>;
     rhs: RNode<Info>;
 }
+/**
+ * Helper for working with {@link RBinaryOp} AST nodes.
+ */
+export declare const RBinaryOp: {
+    readonly name: "RBinaryOp";
+    /**
+     * Type guard for {@link RBinaryOp} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RBinaryOp<Info>;
+    /**
+     * Get the operator information for a binary operator node.
+     */
+    readonly getOperatorInfo: <Info = object>(node: RBinaryOp<Info>) => OperatorInformationValue | undefined;
+};

package/r-bridge/lang-4.x/ast/model/nodes/r-binary-op.js

@@ -1,3 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RBinaryOp = void 0;
+const type_1 = require("../type");
+const operators_1 = require("../operators");
+/**
+ * Helper for working with {@link RBinaryOp} AST nodes.
+ */
+exports.RBinaryOp = {
+    name: 'RBinaryOp',
+    /**
+     * Type guard for {@link RBinaryOp} nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.BinaryOp;
+    },
+    /**
+     * Get the operator information for a binary operator node.
+     */
+    getOperatorInfo(node) {
+        return operators_1.OperatorDatabase[node.operator];
+    }
+};
 //# sourceMappingURL=r-binary-op.js.map

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

@@ -1,8 +1,18 @@
 import type { Leaf, Location, NoInfo } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
 /**
  * A `break` statement.
  */
 export interface RBreak<Info = NoInfo> extends Location, Leaf<Info> {
     readonly type: RType.Break;
 }
+/**
+ * Helper for working with {@link RBreak} AST nodes.
+ */
+export declare const RBreak: {
+    readonly name: "RBreak";
+    /**
+     * Type guard for {@link RBreak} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: unknown) => node is RBreak<Info>;
+};

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

@@ -1,3 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RBreak = void 0;
+const type_1 = require("../type");
+/**
+ * Helper for working with {@link RBreak} AST nodes.
+ */
+exports.RBreak = {
+    name: 'RBreak',
+    /**
+     * Type guard for {@link RBreak} nodes.
+     */
+    is(node) {
+        return typeof node === 'object' && node !== null && node.type === type_1.RType.Break;
+    }
+};
 //# sourceMappingURL=r-break.js.map

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

@@ -9,6 +9,12 @@ export interface RComment<Info = NoInfo> extends Location, Leaf<Info> {
     readonly type: RType.Comment;
 }
 /**
- * Checks whether the given node is an R comment.
+ * Helper for working with {@link RComment} AST nodes.
  */
-export declare function isRComment<Info = NoInfo>(node: unknown): node is RComment<Info>;
+export declare const RComment: {
+    readonly name: "RComment";
+    /**
+     * Type guard for {@link RComment} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: unknown) => node is RComment<Info>;
+};

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

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRComment = isRComment;
+exports.RComment = void 0;
 const type_1 = require("../type");
 /**
- * Checks whether the given node is an R comment.
+ * Helper for working with {@link RComment} AST nodes.
  */
-function isRComment(node) {
-    return typeof node === 'object' && node !== null && node.type === type_1.RType.Comment;
-}
+exports.RComment = {
+    name: 'RComment',
+    /**
+     * Type guard for {@link RComment} nodes.
+     */
+    is(node) {
+        return typeof node === 'object' && node !== null && node.type === type_1.RType.Comment;
+    }
+};
 //# sourceMappingURL=r-comment.js.map

package/r-bridge/lang-4.x/ast/model/nodes/r-expression-list.d.ts

@@ -1,5 +1,5 @@
 import type { RAstNodeBase, Location, NoInfo, RNode, WithChildren } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 /**
  * Holds a list of expressions (and hence may be the root of an AST, summarizing all expressions in a file).
@@ -10,3 +10,25 @@ export interface RExpressionList<Info = NoInfo> extends WithChildren<Info, RNode
     /** encodes wrappers like `{}` or `()` */
     readonly grouping: undefined | [start: RSymbol<Info>, end: RSymbol<Info>];
 }
+/**
+ * Helper for working with {@link RExpressionList} AST nodes.
+ */
+export declare const RExpressionList: {
+    readonly name: "RExpressionList";
+    /**
+     * Type guard for {@link RExpressionList} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RExpressionList<Info>;
+    /**
+     * Type guard for implicit {@link RExpressionList} nodes, i.e., expression lists that are not created by a wrapper like `{}`.
+     */
+    readonly isImplicit: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RExpressionList<Info>;
+    /**
+     * Returns the grouping symbol at the start of the expression list, if it exists. For example, for an expression list created by `{ ... }`, this would return the symbol for `{`.
+     */
+    readonly groupStart: <Info = object>(this: void, node: RExpressionList<Info>) => RSymbol<Info> | undefined;
+    /**
+     * Returns the grouping symbol at the end of the expression list, if it exists. For example, for an expression list created by `{ ... }`, this would return the symbol for `}`.
+     */
+    readonly groupEnd: <Info = object>(this: void, node: RExpressionList<Info>) => RSymbol<Info> | undefined;
+};

package/r-bridge/lang-4.x/ast/model/nodes/r-expression-list.js

@@ -1,3 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RExpressionList = void 0;
+const type_1 = require("../type");
+/**
+ * Helper for working with {@link RExpressionList} AST nodes.
+ */
+exports.RExpressionList = {
+    name: 'RExpressionList',
+    /**
+     * Type guard for {@link RExpressionList} nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.ExpressionList;
+    },
+    /**
+     * Type guard for implicit {@link RExpressionList} nodes, i.e., expression lists that are not created by a wrapper like `{}`.
+     */
+    isImplicit(node) {
+        return exports.RExpressionList.is(node) && node.grouping === undefined;
+    },
+    /**
+     * Returns the grouping symbol at the start of the expression list, if it exists. For example, for an expression list created by `{ ... }`, this would return the symbol for `{`.
+     */
+    groupStart(node) {
+        return node.grouping?.[0];
+    },
+    /**
+     * Returns the grouping symbol at the end of the expression list, if it exists. For example, for an expression list created by `{ ... }`, this would return the symbol for `}`.
+     */
+    groupEnd(node) {
+        return node.grouping?.[1];
+    }
+};
 //# sourceMappingURL=r-expression-list.js.map

package/r-bridge/lang-4.x/ast/model/nodes/r-for-loop.d.ts

@@ -1,5 +1,5 @@
 import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { RExpressionList } from './r-expression-list';
 /**
@@ -16,3 +16,13 @@ export interface RForLoop<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     /** body used in for-loop: <p> `for(... in ...) <body>`*/
     body: RExpressionList<Info>;
 }
+/**
+ * Helper for working with {@link RForLoop} AST nodes.
+ */
+export declare const RForLoop: {
+    readonly name: "RForLoop";
+    /**
+     * Type guard for RForLoop nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RForLoop<Info>;
+};

package/r-bridge/lang-4.x/ast/model/nodes/r-for-loop.js

@@ -1,3 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RForLoop = void 0;
+const type_1 = require("../type");
+/**
+ * Helper for working with {@link RForLoop} AST nodes.
+ */
+exports.RForLoop = {
+    name: 'RForLoop',
+    /**
+     * Type guard for RForLoop nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.ForLoop;
+    }
+};
 //# sourceMappingURL=r-for-loop.js.map

package/r-bridge/lang-4.x/ast/model/nodes/r-function-call.d.ts

@@ -1,5 +1,5 @@
 import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { RArgument } from './r-argument';
 export declare const EmptyArgument = "<>";
@@ -29,3 +29,21 @@ export interface RUnnamedFunctionCall<Info = NoInfo> extends RAstNodeBase<Info>,
     readonly arguments: readonly RFunctionArgument<Info>[];
 }
 export type RFunctionCall<Info = NoInfo> = RNamedFunctionCall<Info> | RUnnamedFunctionCall<Info>;
+/**
+ * Helper for working with {@link RFunctionCall} AST nodes.
+ */
+export declare const RFunctionCall: {
+    readonly name: "RFunctionCall";
+    /**
+     * Type guard for {@link RFunctionCall} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RFunctionCall<Info>;
+    /**
+     * Type guard for {@link RNamedFunctionCall} nodes.
+     */
+    readonly isNamed: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RNamedFunctionCall<Info>;
+    /**
+     * Type guard for {@link RUnnamedFunctionCall} nodes.
+     */
+    readonly isUnnamed: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RUnnamedFunctionCall<Info>;
+};

package/r-bridge/lang-4.x/ast/model/nodes/r-function-call.js

@@ -1,5 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptyArgument = void 0;
+exports.RFunctionCall = exports.EmptyArgument = void 0;
+const type_1 = require("../type");
 exports.EmptyArgument = '<>';
+/**
+ * Helper for working with {@link RFunctionCall} AST nodes.
+ */
+exports.RFunctionCall = {
+    name: 'RFunctionCall',
+    /**
+     * Type guard for {@link RFunctionCall} nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.FunctionCall;
+    },
+    /**
+     * Type guard for {@link RNamedFunctionCall} nodes.
+     */
+    isNamed(node) {
+        return exports.RFunctionCall.is(node) && node.named === true;
+    },
+    /**
+     * Type guard for {@link RUnnamedFunctionCall} nodes.
+     */
+    isUnnamed(node) {
+        return exports.RFunctionCall.is(node) && !node.named;
+    }
+};
 //# sourceMappingURL=r-function-call.js.map

package/r-bridge/lang-4.x/ast/model/nodes/r-function-definition.d.ts

@@ -1,5 +1,5 @@
 import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
 import type { RParameter } from './r-parameter';
 /**
  * ```r
@@ -16,3 +16,13 @@ export interface RFunctionDefinition<Info = NoInfo> extends RAstNodeBase<Info>,
     parameters: RParameter<Info>[];
     body: RNode<Info>;
 }
+/**
+ * Helper for working with {@link RFunctionDefinition} AST nodes.
+ */
+export declare const RFunctionDefinition: {
+    readonly name: "RFunctionDefinition";
+    /**
+     * Type guard for {@link RFunctionDefinition} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RFunctionDefinition<Info>;
+};

package/r-bridge/lang-4.x/ast/model/nodes/r-function-definition.js

@@ -1,3 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RFunctionDefinition = void 0;
+const type_1 = require("../type");
+/**
+ * Helper for working with {@link RFunctionDefinition} AST nodes.
+ */
+exports.RFunctionDefinition = {
+    name: 'RFunctionDefinition',
+    /**
+     * Type guard for {@link RFunctionDefinition} nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.FunctionDefinition;
+    }
+};
 //# sourceMappingURL=r-function-definition.js.map

package/r-bridge/lang-4.x/ast/model/nodes/r-if-then-else.d.ts

@@ -1,5 +1,5 @@
 import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
 import type { RExpressionList } from './r-expression-list';
 /**
  * ```r
@@ -12,3 +12,13 @@ export interface RIfThenElse<Info = NoInfo> extends RAstNodeBase<Info>, Location
     then: RExpressionList<Info>;
     otherwise?: RExpressionList<Info>;
 }
+/**
+ * Helper for working with {@link RIfThenElse} AST nodes.
+ */
+export declare const RIfThenElse: {
+    readonly name: "RIfThenElse";
+    /**
+     * Type guard for {@link RIfThenElse} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RIfThenElse<Info>;
+};

package/r-bridge/lang-4.x/ast/model/nodes/r-if-then-else.js

@@ -1,3 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RIfThenElse = void 0;
+const type_1 = require("../type");
+/**
+ * Helper for working with {@link RIfThenElse} AST nodes.
+ */
+exports.RIfThenElse = {
+    name: 'RIfThenElse',
+    /**
+     * Type guard for {@link RIfThenElse} nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.IfThenElse;
+    }
+};
 //# sourceMappingURL=r-if-then-else.js.map

package/r-bridge/lang-4.x/ast/model/nodes/r-line-directive.d.ts

@@ -1,5 +1,5 @@
-import type { Leaf, Location, NoInfo } from '../model';
-import type { RType } from '../type';
+import type { Leaf, Location, NoInfo, RNode } from '../model';
+import { RType } from '../type';
 /**
  * Special comment to signal line mappings (e.g., in generated code) to the interpreter.
  */
@@ -8,3 +8,13 @@ export interface RLineDirective<Info = NoInfo> extends Location, Leaf<Info> {
     line: number;
     file: string;
 }
+/**
+ * Helper for working with {@link RLineDirective} AST nodes.
+ */
+export declare const RLineDirective: {
+    readonly name: "RLineDirective";
+    /**
+     * Type guard for {@link RLineDirective} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RLineDirective<Info>;
+};

package/r-bridge/lang-4.x/ast/model/nodes/r-line-directive.js

@@ -1,3 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RLineDirective = void 0;
+const type_1 = require("../type");
+/**
+ * Helper for working with {@link RLineDirective} AST nodes.
+ */
+exports.RLineDirective = {
+    name: 'RLineDirective',
+    /**
+     * Type guard for {@link RLineDirective} nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.LineDirective;
+    }
+};
 //# sourceMappingURL=r-line-directive.js.map

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

@@ -1,5 +1,5 @@
-import type { Leaf, Location, NoInfo } from '../model';
-import type { RType } from '../type';
+import type { Leaf, Location, NoInfo, RNode } from '../model';
+import { RType } from '../type';
 export type RLogicalValue = boolean;
 /**
  * Represents logical values (`TRUE` or `FALSE`).
@@ -8,3 +8,21 @@ export interface RLogical<Info = NoInfo> extends Leaf<Info>, Location {
     readonly type: RType.Logical;
     content: RLogicalValue;
 }
+/**
+ * Helper for working with {@link RLogical} AST nodes.
+ */
+export declare const RLogical: {
+    readonly name: "RLogical";
+    /**
+     * Type guard for {@link RLogical} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RLogical<Info>;
+    /**
+     * Checks whether a node is a logical constant with value `TRUE`.
+     */
+    readonly isTrue: <Info = object>(this: void, node: RNode<Info> | undefined) => boolean;
+    /**
+     * Checks whether a node is a logical constant with value `FALSE`.
+     */
+    readonly isFalse: <Info = object>(this: void, node: RNode<Info> | undefined) => boolean;
+};

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

@@ -1,3 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RLogical = void 0;
+const type_1 = require("../type");
+/**
+ * Helper for working with {@link RLogical} AST nodes.
+ */
+exports.RLogical = {
+    name: 'RLogical',
+    /**
+     * Type guard for {@link RLogical} nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.Logical;
+    },
+    /**
+     * Checks whether a node is a logical constant with value `TRUE`.
+     */
+    isTrue(node) {
+        return exports.RLogical.is(node) && node.content;
+    },
+    /**
+     * Checks whether a node is a logical constant with value `FALSE`.
+     */
+    isFalse(node) {
+        return exports.RLogical.is(node) && !node.content;
+    }
+};
 //# sourceMappingURL=r-logical.js.map

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

@@ -1,8 +1,18 @@
-import type { Leaf, Location, NoInfo } from '../model';
-import type { RType } from '../type';
+import type { Leaf, Location, NoInfo, RNode } from '../model';
+import { RType } from '../type';
 /**
  * A `next` statement.
  */
 export interface RNext<Info = NoInfo> extends Location, Leaf<Info> {
     readonly type: RType.Next;
 }
+/**
+ * Helper for working with {@link RNext} AST nodes.
+ */
+export declare const RNext: {
+    readonly name: "RNext";
+    /**
+     * Type guard for {@link RNext} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RNext<Info>;
+};

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

@@ -1,3 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RNext = void 0;
+const type_1 = require("../type");
+/**
+ * Helper for working with {@link RNext} AST nodes.
+ */
+exports.RNext = {
+    name: 'RNext',
+    /**
+     * Type guard for {@link RNext} nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.Next;
+    }
+};
 //# sourceMappingURL=r-next.js.map

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

@@ -11,6 +11,12 @@ export interface RNumber<Info = NoInfo> extends Leaf<Info>, Location {
     content: RNumberValue;
 }
 /**
- * Checks whether the given node is an RNumber.
+ * Helper for working with {@link RNumber} AST nodes.
  */
-export declare function isRNumber(node: RNode | undefined): node is RNumber;
+export declare const RNumber: {
+    readonly name: "RNumber";
+    /**
+     * Type guard for {@link RNumber} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RNumber<Info>;
+};

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

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRNumber = isRNumber;
+exports.RNumber = void 0;
 const type_1 = require("../type");
 /**
- * Checks whether the given node is an RNumber.
+ * Helper for working with {@link RNumber} AST nodes.
  */
-function isRNumber(node) {
-    return node?.type === type_1.RType.Number;
-}
+exports.RNumber = {
+    name: 'RNumber',
+    /**
+     * Type guard for {@link RNumber} nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.Number;
+    }
+};
 //# sourceMappingURL=r-number.js.map

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

@@ -1,5 +1,5 @@
 import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { BrandedIdentifier } from '../../../../../dataflow/environments/identifier';
 /**
@@ -12,3 +12,19 @@ export interface RParameter<Info = NoInfo> extends RAstNodeBase<Info>, Location
     special: boolean;
     defaultValue: RNode<Info> | undefined;
 }
+/**
+ * Helper for working with {@link RParameter} AST nodes.
+ */
+export declare const RParameter: {
+    readonly name: "RParameter";
+    /**
+     * Type guard for {@link RParameter} nodes.
+     * @see {@link RParameter.isDotDotDotDot} - to check whether a parameter is the special `...` parameter
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RParameter<Info>;
+    /**
+     * Type guard for the special `...` parameter.
+     * @see {@link RParameter.is} - to check whether a node is a parameter at all
+     */
+    readonly isDotDotDotDot: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RParameter<Info>;
+};