@eagleoutice/flowr 2.7.6 → 2.8.0

package/r-bridge/data/data.js

@@ -217,6 +217,12 @@ ${await (0, doc_dfg_1.printDfGraphForCode)(parser, code, { simplified: true })}
                                 }
                             ]
                         },
+                        {
+                            name: 'Recursion',
+                            id: 'recursion',
+                            supported: 'fully',
+                            description: '_Recognize and resolve recursive calls like `f(3)` inside the definition of `f`, ..._'
+                        },
                         {
                             name: 'Anonymous Calls',
                             id: 'call-anonymous',
@@ -446,9 +452,9 @@ ${await (0, doc_dfg_1.printDfGraphForCode)(parser, code, { simplified: true })}
                                     description: '_Handle `return(3)`, ... in function definitions_'
                                 },
                                 {
-                                    name: 'exceptions',
-                                    id: 'exceptions',
-                                    supported: 'not',
+                                    name: 'Exceptions and Errors',
+                                    id: 'exceptions-and-errors',
+                                    supported: 'partially',
                                     description: '_Handle `try`, `stop`, ..._'
                                 }
                             ]
@@ -652,7 +658,7 @@ ${await (0, doc_dfg_1.printDfGraphForCode)(parser, code, { simplified: true })}
                 {
                     name: 'Hooks',
                     id: 'hooks',
-                    supported: 'not',
+                    supported: 'partially',
                     description: '_Handle hooks like [`userhooks`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/userhooks.html) and [`on.exit`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/on.exit)._ We do not support hooks.'
                 },
                 {
@@ -728,7 +734,7 @@ ${await (0, doc_dfg_1.printDfGraphForCode)(parser, code, { simplified: true })}
                             url: [
                                 { name: AdvancedR('S4'), href: 'https://adv-r.hadley.nz/s4.html' }
                             ],
-                            supported: 'not',
+                            supported: 'partially',
                             description: '_Handle S4 classes and methods as one unit. Including Dispatch and Inheritance_ We do not support typing currently and do not handle objects of these classes "as units."'
                         },
                         {

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

@@ -23,7 +23,7 @@ import type { RUnaryOp } from './nodes/r-unary-op';
 import type { RBinaryOp } from './nodes/r-binary-op';
 import type { RPipe } from './nodes/r-pipe';
 import type { RDelimiter } from './nodes/info/r-delimiter';
-/** Simply an empty type constraint used to say that there are additional decorations (see {@link Base}). */
+/** Simply an empty type constraint used to say that there are additional decorations (see {@link RAstNodeBase}). */
 export type NoInfo = object;
 /**
  * Will be used to reconstruct the source of the given element in the R-ast.
@@ -57,27 +57,27 @@ interface Source {
  * @typeParam Info       - can be used to store additional information about the node
  * @typeParam LexemeType - the type of the lexeme, probably always a `string` or `string | undefined`
  */
-export interface Base<Info, LexemeType = string> extends MergeableRecord {
+export interface RAstNodeBase<Info, LexemeType = string> extends MergeableRecord {
     type: RType;
     /** the original string retrieved from R, can be used for further identification */
     lexeme: LexemeType;
     /** allows to attach additional information to the node */
     info: Info & Source;
 }
-export interface WithChildren<Info, Children extends Base<Info, string | undefined>> {
+export interface WithChildren<Info, Children extends RAstNodeBase<Info, string | undefined>> {
     children: readonly Children[];
 }
 /**
  * A helper interface we use to "mark" leaf nodes.
  * <p>
  * Please be aware, that this is not marking from a language perspective,
- * as it is equivalent to the {@link Base} interface.
+ * as it is equivalent to the {@link RAstNodeBase} interface.
  * It is intended to help humans understand the code.
  */
-export interface Leaf<Info = NoInfo, LexemeType = string> extends Base<Info, LexemeType> {
+export interface Leaf<Info = NoInfo, LexemeType = string> extends RAstNodeBase<Info, LexemeType> {
 }
 /**
- * Indicates, that the respective {@link Base} node has known source code
+ * Indicates, that the respective {@link RAstNodeBase} node has known source code
  * location information.
  */
 export interface Location {
@@ -95,7 +95,7 @@ export interface Location {
 export type NamespaceIdentifier = string;
 /**
  * Similar to {@link Location} this is an interface that indicates that
- * the respective {@link Base} node has a respective property (a namespace).
+ * the respective {@link RAstNodeBase} node has a respective property (a namespace).
  */
 export interface Namespace {
     /**

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

@@ -1,11 +1,11 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RArgument, RUnnamedArgument } from './r-argument';
 import type { EmptyArgument } from './r-function-call';
 /**
  * Represents an R Indexing operation with `$`, `@`, `[[`, or `[`.
  */
-interface RAccessBase<Info = NoInfo> extends Base<Info>, Location {
+interface RAccessBase<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.Access;
     /** the accessed container/variable/expression */
     accessed: RNode<Info>;

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

@@ -1,10 +1,10 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 /**
  * Represents a named or unnamed argument of a function definition in R.
  */
-export interface RArgument<Info = NoInfo> extends Base<Info>, Location {
+export interface RArgument<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.Argument;
     name: RSymbol<Info> | undefined;
     value: RNode<Info> | undefined;

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

@@ -1,9 +1,9 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 /**
  * Operators like `+`, `==`, `&&`, etc.
  */
-export interface RBinaryOp<Info = NoInfo> extends Base<Info>, Location {
+export interface RBinaryOp<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.BinaryOp;
     operator: string;
     lhs: RNode<Info>;

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

@@ -1,5 +1,5 @@
 import type { Leaf, Location, NoInfo } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
 /**
  * ```r
  * # I am a line comment
@@ -7,5 +7,8 @@ import type { RType } from '../type';
  */
 export interface RComment<Info = NoInfo> extends Location, Leaf<Info> {
     readonly type: RType.Comment;
-    content: string;
 }
+/**
+ * Checks whether the given node is an R comment.
+ */
+export declare function isRComment<Info = NoInfo>(node: unknown): node is RComment<Info>;

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

@@ -1,3 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRComment = isRComment;
+const type_1 = require("../type");
+/**
+ * Checks whether the given node is an R comment.
+ */
+function isRComment(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,11 +1,11 @@
-import type { Base, Location, NoInfo, RNode, WithChildren } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode, WithChildren } from '../model';
 import type { 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).
  * The `grouping` property holds information on if the expression list is structural or created by a wrapper like `{}` or `()`.
  */
-export interface RExpressionList<Info = NoInfo> extends WithChildren<Info, RNode<Info>>, Base<Info, string | undefined>, Partial<Location> {
+export interface RExpressionList<Info = NoInfo> extends WithChildren<Info, RNode<Info>>, RAstNodeBase<Info, string | undefined>, Partial<Location> {
     readonly type: RType.ExpressionList;
     /** encodes wrappers like `{}` or `()` */
     readonly grouping: undefined | [start: RSymbol<Info>, end: RSymbol<Info>];

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

@@ -1,4 +1,4 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { RExpressionList } from './r-expression-list';
@@ -7,7 +7,7 @@ import type { RExpressionList } from './r-expression-list';
  * for(<variable> in <vector>) <body>
  * ```
  */
-export interface RForLoop<Info = NoInfo> extends Base<Info>, Location {
+export interface RForLoop<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.ForLoop;
     /** variable used in for-loop: <p> `for(<variable> in ...) ...`*/
     variable: RSymbol<Info>;

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

@@ -1,4 +1,4 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { RArgument } from './r-argument';
@@ -8,7 +8,7 @@ export type RFunctionArgument<Info = NoInfo> = RArgument<Info> | typeof EmptyArg
  * Calls of functions like `a()` and `foo(42, "hello")`.
  * @see RUnnamedFunctionCall
  */
-export interface RNamedFunctionCall<Info = NoInfo> extends Base<Info>, Location {
+export interface RNamedFunctionCall<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.FunctionCall;
     readonly named: true;
     functionName: RSymbol<Info>;
@@ -19,7 +19,7 @@ export interface RNamedFunctionCall<Info = NoInfo> extends Base<Info>, Location
  * Direct calls of functions like `(function(x) { x })(3)`.
  * @see RNamedFunctionCall
  */
-export interface RUnnamedFunctionCall<Info = NoInfo> extends Base<Info>, Location {
+export interface RUnnamedFunctionCall<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.FunctionCall;
     readonly named: false | undefined;
     calledFunction: RNode<Info>;

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

@@ -1,4 +1,4 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RParameter } from './r-parameter';
 /**
@@ -10,7 +10,7 @@ import type { RParameter } from './r-parameter';
  * \(<parameters>) <body>
  * ```
  */
-export interface RFunctionDefinition<Info = NoInfo> extends Base<Info>, Location {
+export interface RFunctionDefinition<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.FunctionDefinition;
     /** the R formals, to our knowledge, they must be unique */
     parameters: RParameter<Info>[];

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

@@ -1,4 +1,4 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RExpressionList } from './r-expression-list';
 /**
@@ -6,7 +6,7 @@ import type { RExpressionList } from './r-expression-list';
  * if(<condition>) <then> [else <otherwise>]
  * ```
  */
-export interface RIfThenElse<Info = NoInfo> extends Base<Info>, Location {
+export interface RIfThenElse<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.IfThenElse;
     condition: RNode<Info>;
     then: RExpressionList<Info>;

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

@@ -1,10 +1,10 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 /**
  * Represents a parameter of a function definition in R.
  */
-export interface RParameter<Info = NoInfo> extends Base<Info>, Location {
+export interface RParameter<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.Parameter;
     name: RSymbol<Info>;
     /** is it the special ... parameter? */

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

@@ -1,9 +1,9 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 /**
  * Variant of the binary operator, specifically for the new, built-in pipe operator.
  */
-export interface RPipe<Info = NoInfo> extends Base<Info>, Location {
+export interface RPipe<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.Pipe;
     readonly lhs: RNode<Info>;
     readonly rhs: RNode<Info>;

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

@@ -1,4 +1,4 @@
-import type { Base, Location, NoInfo } from '../model';
+import type { RAstNodeBase, Location, NoInfo } from '../model';
 import type { RType } from '../type';
 import type { RExpressionList } from './r-expression-list';
 /**
@@ -6,7 +6,7 @@ import type { RExpressionList } from './r-expression-list';
  * repeat <body>
  * ```
  */
-export interface RRepeatLoop<Info = NoInfo> extends Base<Info>, Location {
+export interface RRepeatLoop<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.RepeatLoop;
     body: RExpressionList<Info>;
 }

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

@@ -1,9 +1,9 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 /**
  * Unary operations like `+` and `-`
  */
-export interface RUnaryOp<Info = NoInfo> extends Base<Info>, Location {
+export interface RUnaryOp<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.UnaryOp;
     operator: string;
     operand: RNode<Info>;

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

@@ -1,4 +1,4 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RExpressionList } from './r-expression-list';
 /**
@@ -6,7 +6,7 @@ import type { RExpressionList } from './r-expression-list';
  * while(<condition>) <body>
  * ```
  */
-export interface RWhileLoop<Info = NoInfo> extends Base<Info>, Location {
+export interface RWhileLoop<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.WhileLoop;
     condition: RNode<Info>;
     body: RExpressionList<Info>;

package/r-bridge/lang-4.x/ast/parser/main/internal/other/normalize-comment.js

@@ -16,7 +16,6 @@ function normalizeComment(data, obj) {
     return {
         type: type_1.RType.Comment,
         location,
-        content: content.slice(1),
         lexeme: content,
         info: {
             fullRange: data.currentRange,

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-normalize.js

@@ -552,7 +552,6 @@ function convertTreeNode(node) {
             return {
                 type: type_1.RType.Comment,
                 location: range,
-                content: node.text.slice(1),
                 lexeme: node.text,
                 ...defaultInfo
             };
@@ -594,7 +593,6 @@ function splitComments(nodes) {
             comments.push([node, {
                     type: type_1.RType.Comment,
                     location: makeSourceRange(node),
-                    content: node.text.slice(1),
                     lexeme: node.text,
                     info: {
                         additionalTokens: [],

package/r-bridge/roxygen2/roxygen-ast.d.ts

@@ -0,0 +1,218 @@
+import type { SourceLocation } from '../../util/range';
+import type { NodeId } from '../lang-4.x/ast/model/processing/node-id';
+/**
+ * Known Roxygen tags as per {@link https://roxygen2.r-lib.org/reference/index.html}
+ */
+export declare enum KnownRoxygenTags {
+    Aliases = "aliases",
+    Backref = "backref",
+    Concept = "concept",
+    Family = "family",
+    Keywords = "keywords",
+    References = "references",
+    SeeAlso = "seealso",
+    EvalNamespace = "evalNamespace",
+    Export = "export",
+    ExportClass = "exportClass",
+    ExportMethod = "exportMethod",
+    ExportPattern = "exportPattern",
+    ExportS3Method = "exportS3Method",
+    Import = "import",
+    ImportClassesFrom = "importClassesFrom",
+    ImportMethodsFrom = "importMethodsFrom",
+    ImportFrom = "importFrom",
+    RawNamespace = "rawNamespace",
+    UseDynLib = "useDynLib",
+    Md = "md",
+    NoMd = "noMd",
+    Section = "section",
+    Field = "field",
+    Format = "format",
+    Method = "method",
+    Slot = "slot",
+    Source = "source",
+    Description = "description",
+    Details = "details",
+    Example = "example",
+    Examples = "examples",
+    ExamplesIf = "examplesIf",
+    NoRd = "noRd",
+    Param = "param",
+    RawRd = "rawRd",
+    Return = "return",
+    Returns = "returns",
+    Title = "title",
+    Usage = "usage",
+    DescribeIn = "describeIn",
+    Eval = "eval",
+    EvalRd = "evalRd",
+    IncludeRmd = "includeRmd",
+    Inherit = "inherit",
+    InheritDotParams = "inheritDotParams",
+    InheritParams = "inheritParams",
+    InheritSection = "inheritSection",
+    Order = "order",
+    RdName = "rdname",
+    Template = "template",
+    TemplateVar = "templateVar",
+    /** Just plain old text */
+    Text = "text",
+    Name = "name",
+    DocType = "docType",
+    Author = "author",
+    Unknown = "unknown"
+}
+/**
+ * Base interface for all roxygen tags.
+ */
+export interface RoxygenTagBase<Type extends KnownRoxygenTags> {
+    /** The type of the roxygen tag. */
+    type: Type;
+}
+interface RoxygenTagWithValue<Type extends KnownRoxygenTags, Value> extends RoxygenTagBase<Type> {
+    /** The value of the roxygen tag. */
+    value: Value;
+}
+type RoxygenTagFlag<Type extends KnownRoxygenTags> = RoxygenTagBase<Type>;
+export type RoxygenTagAlias = RoxygenTagWithValue<KnownRoxygenTags.Aliases, string[]>;
+export type RoxygenTagBackref = RoxygenTagWithValue<KnownRoxygenTags.Backref, string>;
+export type RoxygenTagConcept = RoxygenTagWithValue<KnownRoxygenTags.Concept, string>;
+export type RoxygenTagFamily = RoxygenTagWithValue<KnownRoxygenTags.Family, string>;
+/** Internal is special in that it causes the topic to be removed from the index */
+export type RoxygenTagKeywords = RoxygenTagWithValue<KnownRoxygenTags.Keywords, (string | 'internal')[]>;
+export type RoxygenTagReferences = RoxygenTagWithValue<KnownRoxygenTags.References, string>;
+export type RoxygenTagSeeAlso = RoxygenTagWithValue<KnownRoxygenTags.SeeAlso, string[]>;
+/** https://roxygen2.r-lib.org/reference/tags-index-crossref.html */
+export type RoxygenCrossrefTag = RoxygenTagAlias | RoxygenTagBackref | RoxygenTagConcept | RoxygenTagFamily | RoxygenTagKeywords | RoxygenTagReferences | RoxygenTagSeeAlso;
+/** Evaluate arbitrary code in the package namespace and insert the results into the NAMESPACE */
+export type RoxygenTagEvalNamespace = RoxygenTagWithValue<KnownRoxygenTags.EvalNamespace, string>;
+export type RoxygenTagExport = RoxygenTagFlag<KnownRoxygenTags.Export>;
+export type RoxygenTagExportClass = RoxygenTagWithValue<KnownRoxygenTags.ExportClass, string>;
+export type RoxygenTagExportMethod = RoxygenTagWithValue<KnownRoxygenTags.ExportMethod, string>;
+export type RoxygenTagExportPattern = RoxygenTagWithValue<KnownRoxygenTags.ExportPattern, string>;
+export type RoxygenTagExportS3Method = RoxygenTagWithValue<KnownRoxygenTags.ExportS3Method, string>;
+export type RoxygenTagImport = RoxygenTagWithValue<KnownRoxygenTags.Import, string>;
+export type RoxygenTagImportClassesFrom = RoxygenTagWithValue<KnownRoxygenTags.ImportClassesFrom, {
+    package: string;
+    classes: string[];
+}>;
+export type RoxygenTagImportMethodsFrom = RoxygenTagWithValue<KnownRoxygenTags.ImportMethodsFrom, {
+    package: string;
+    methods: string[];
+}>;
+export type RoxygenTagImportFrom = RoxygenTagWithValue<KnownRoxygenTags.ImportFrom, {
+    package: string;
+    symbols: string[];
+}>;
+/** Insert literal text directly into the NAMESPACE */
+export type RoxygenTagRawNamespace = RoxygenTagWithValue<KnownRoxygenTags.RawNamespace, string>;
+export type RoxygenTagUseDynLib = RoxygenTagWithValue<KnownRoxygenTags.UseDynLib, string>;
+/** https://roxygen2.r-lib.org/reference/tags-namespace.html */
+export type RoxygenNamespaceTag = RoxygenTagEvalNamespace | RoxygenTagExport | RoxygenTagExportClass | RoxygenTagExportMethod | RoxygenTagExportPattern | RoxygenTagExportS3Method | RoxygenTagImport | RoxygenTagImportClassesFrom | RoxygenTagImportMethodsFrom | RoxygenTagImportFrom | RoxygenTagRawNamespace | RoxygenTagUseDynLib;
+export type RoxygenTagMarkdown = RoxygenTagFlag<KnownRoxygenTags.Md>;
+export type RoxygenTagNoMarkdown = RoxygenTagFlag<KnownRoxygenTags.NoMd>;
+export type RoxygenTagSection = RoxygenTagWithValue<KnownRoxygenTags.Section, {
+    title: string;
+    content: string;
+}>;
+/** https://roxygen2.r-lib.org/reference/tags-rd-formatting.html */
+export type RoxygenFormattingTag = RoxygenTagMarkdown | RoxygenTagNoMarkdown | RoxygenTagSection;
+export type RoxygenTagField = RoxygenTagWithValue<KnownRoxygenTags.Field, {
+    name: string;
+    description: string;
+}>;
+export type RoxygenTagFormat = RoxygenTagWithValue<KnownRoxygenTags.Format, string>;
+export type RoxygenTagMethod = RoxygenTagWithValue<KnownRoxygenTags.Method, {
+    generic: string;
+    class: string;
+}>;
+export type RoxygenTagSlot = RoxygenTagWithValue<KnownRoxygenTags.Slot, {
+    name: string;
+    description: string;
+}>;
+export type RoxygenTagSource = RoxygenTagWithValue<KnownRoxygenTags.Source, string>;
+/** https://roxygen2.r-lib.org/reference/tags-rd-other.html */
+export type RoxygenDatasetDocumentationTag = RoxygenTagField | RoxygenTagFormat | RoxygenTagMethod | RoxygenTagSlot | RoxygenTagSource;
+export type RoxygenTagDescription = RoxygenTagWithValue<KnownRoxygenTags.Description, string>;
+export type RoxygenTagDetails = RoxygenTagWithValue<KnownRoxygenTags.Details, string>;
+/** Embed example from file */
+export type RoxygenTagExample = RoxygenTagWithValue<KnownRoxygenTags.Example, string>;
+export type RoxygenTagExamples = RoxygenTagWithValue<KnownRoxygenTags.Examples, string>;
+export type RoxygenTagExamplesIf = RoxygenTagWithValue<KnownRoxygenTags.ExamplesIf, {
+    condition: string;
+    content: string;
+}>;
+export type RoxygenTagNoRd = RoxygenTagFlag<KnownRoxygenTags.NoRd>;
+export type RoxygenTagParam = RoxygenTagWithValue<KnownRoxygenTags.Param, {
+    name: string;
+    description: string;
+}>;
+/** Insert literal Rd code */
+export type RoxygenTagRawRd = RoxygenTagWithValue<KnownRoxygenTags.RawRd, string>;
+export type RoxygenTagReturn = RoxygenTagWithValue<KnownRoxygenTags.Return | KnownRoxygenTags.Returns, string>;
+export type RoxygenTagTitle = RoxygenTagWithValue<KnownRoxygenTags.Title, string>;
+export type RoxygenTagUsage = RoxygenTagWithValue<KnownRoxygenTags.Usage, string>;
+/** https://roxygen2.r-lib.org/reference/tags-rd.html */
+export type RoxygenFunctionDocumentationTag = RoxygenTagDescription | RoxygenTagDetails | RoxygenTagExample | RoxygenTagExamples | RoxygenTagExamplesIf | RoxygenTagNoRd | RoxygenTagParam | RoxygenTagRawRd | RoxygenTagReturn | RoxygenTagTitle | RoxygenTagUsage;
+export type RoxygenTagDescribeIn = RoxygenTagWithValue<KnownRoxygenTags.DescribeIn, {
+    dest: string;
+    description: string;
+}>;
+/** Evaluate R code and insert the results into the Rd file */
+export type RoxygenTagEval = RoxygenTagWithValue<KnownRoxygenTags.Eval, string>;
+export type RoxygenTagEvalRd = RoxygenTagWithValue<KnownRoxygenTags.EvalRd, string>;
+export type RoxygenTagIncludeRmd = RoxygenTagWithValue<KnownRoxygenTags.IncludeRmd, string>;
+export type RoxygenTagInherit = RoxygenTagWithValue<KnownRoxygenTags.Inherit, {
+    source: string;
+    components: string[];
+}>;
+export type RoxygenTagInheritDotParams = RoxygenTagWithValue<KnownRoxygenTags.InheritDotParams, {
+    source: string;
+    args: string[];
+}>;
+export type RoxygenTagInheritParams = RoxygenTagWithValue<KnownRoxygenTags.InheritParams, string>;
+export type RoxygenTagInheritSection = RoxygenTagWithValue<KnownRoxygenTags.InheritSection, {
+    source: string;
+    section: string;
+}>;
+export type RoxygenTagOrder = RoxygenTagWithValue<KnownRoxygenTags.Order, number | undefined>;
+export type RoxygenTagRdName = RoxygenTagWithValue<KnownRoxygenTags.RdName, string>;
+export type RoxygenTagTemplate = RoxygenTagWithValue<KnownRoxygenTags.Template, string>;
+export type RoxygenTagTemplateVar = RoxygenTagWithValue<KnownRoxygenTags.TemplateVar, {
+    name: string;
+    value: string;
+}>;
+/** https://roxygen2.r-lib.org/reference/tags-reuse.html */
+export type RoxygenReusingDocumentationTag = RoxygenTagDescribeIn | RoxygenTagEval | RoxygenTagEvalRd | RoxygenTagIncludeRmd | RoxygenTagInherit | RoxygenTagInheritDotParams | RoxygenTagInheritParams | RoxygenTagInheritSection | RoxygenTagOrder | RoxygenTagRdName | RoxygenTagTemplate | RoxygenTagTemplateVar;
+export type RoxygenUnknownTag = RoxygenTagWithValue<KnownRoxygenTags.Unknown, {
+    tag: string;
+    content: string;
+}>;
+export type RoxygenTagAuthor = RoxygenTagWithValue<KnownRoxygenTags.Author, string>;
+export type RoxygenDocType = RoxygenTagWithValue<KnownRoxygenTags.DocType, string>;
+export type RoxygenTagName = RoxygenTagWithValue<KnownRoxygenTags.Name, string>;
+export type RoxygenTagText = RoxygenTagWithValue<KnownRoxygenTags.Text, string>;
+export type RoxygenOtherTag = RoxygenTagAuthor | RoxygenUnknownTag | RoxygenDocType | RoxygenTagName | RoxygenTagText;
+/**
+ * All known Roxygen tag types.
+ */
+export type RoxygenTag = RoxygenCrossrefTag | RoxygenNamespaceTag | RoxygenFormattingTag | RoxygenDatasetDocumentationTag | RoxygenFunctionDocumentationTag | RoxygenReusingDocumentationTag | RoxygenOtherTag;
+/**
+ * A roxygen comment block, consisting of multiple {@link RoxygenTag|roxygen tags}.
+ */
+export interface RoxygenBlock {
+    readonly type: 'roxygen-block';
+    /** The ast node to which we assign the comment */
+    readonly requestNode: NodeId;
+    /** The AST node ID of the R node this roxygen block is attached to, if any (this comment may be a parent of the requested) */
+    readonly attachedTo?: NodeId;
+    /** The source location of the entire roxygen block, if available. */
+    readonly range?: SourceLocation;
+    /** The roxygen tags contained in this block. */
+    readonly tags: readonly RoxygenTag[];
+}
+/**
+ * Checks whether the given text is a known roxygen tag.
+ */
+export declare function isKnownRoxygenText(text: string): text is KnownRoxygenTags;
+export {};