yuku-ast 0.0.3

package/dist/index.d.mts

@@ -0,0 +1,641 @@
+import * as t from "yuku-parser";
+import { BigIntLiteral, BindingIdentifier, BooleanLiteral, ComputedMemberExpression, Directive, IdentifierName, IdentifierReference, LabelIdentifier, Node, NullLiteral, NumericLiteral, PrivateFieldExpression, RegExpLiteral, StaticMemberExpression, StringLiteral } from "yuku-parser";
+
+//#region src/types.d.ts
+/** Discriminant `type` string of every AST node. */
+type NodeType = Node["type"];
+/** The node, or union of nodes, carrying a given `type`. */
+type NodeOfType<K extends NodeType> = Extract<Node, {
+  type: K;
+}>;
+/** Field names of a node whose values hold child nodes. */
+type ChildKeys<N> = { [K in keyof N]-?: [NonNullable<N[K]>] extends [never] ? never : NonNullable<N[K]> extends Node ? K : NonNullable<N[K]> extends readonly (infer E)[] ? NonNullable<E> extends Node ? K : never : never }[keyof N];
+/**
+ * A node's position in the tree, passed to every visitor. It exposes the
+ * surrounding context and the operations for changing the tree. Each node has
+ * its own path, so a path stays valid after its visit returns.
+ */
+interface Path<T extends Node = Node, S = unknown> {
+  /** The node being visited. */
+  readonly node: T;
+  /** The node that holds {@link node}, or null at the root. */
+  readonly parent: Node | null;
+  /** The field on {@link parent} that holds {@link node} or its array, or null at the root. */
+  readonly key: string | null;
+  /** Index of {@link node} within an array field, or null when it sits in a plain field. */
+  readonly index: number | null;
+  /** Ancestors from the root down to {@link parent}, excluding {@link node}. */
+  readonly ancestors: readonly Node[];
+  /** State threaded through the walk. */
+  state: S;
+  /** Do not descend into the current node's children. */
+  skip(): void;
+  /** Stop the walk entirely. */
+  stop(): void;
+  /** Replace the current node, then walk the replacement's children. */
+  replace(next: Node): void;
+  /** Remove the current node from its parent. */
+  remove(): void;
+  /** Insert a sibling before the current node. Only valid in an array field. */
+  insertBefore(node: Node): void;
+  /** Insert a sibling after the current node. Only valid in an array field. */
+  insertAfter(node: Node): void;
+}
+/** Handler invoked with a node and the {@link Path} cursor. */
+type VisitFn<T extends Node, S> = (node: T, path: Path<T, S>) => void;
+/** A visitor: a function run on enter, or an object with `enter` and/or `leave`. */
+type Visitor<T extends Node, S> = VisitFn<T, S> | {
+  enter?: VisitFn<T, S>;
+  leave?: VisitFn<T, S>;
+};
+/**
+ * Visitors passed to {@link walk}. A key may be a node `type`, an alias group
+ * such as `Function` or `Expression`, or `enter`/`leave` to match every node.
+ */
+type Visitors<S = unknown> = { [K in NodeType]?: Visitor<NodeOfType<K>, S> } & { [K in keyof AliasMap]?: Visitor<AliasMap[K], S> } & {
+  enter?: VisitFn<Node, S>;
+  leave?: VisitFn<Node, S>;
+};
+/** Like {@link VisitFn}, but may return a promise that the walk awaits. */
+type AsyncVisitFn<T extends Node, S> = (node: T, path: Path<T, S>) => void | Promise<void>;
+/** A visitor for {@link walkAsync}: a function, or an object with `enter` and/or `leave`. */
+type AsyncVisitor<T extends Node, S> = AsyncVisitFn<T, S> | {
+  enter?: AsyncVisitFn<T, S>;
+  leave?: AsyncVisitFn<T, S>;
+};
+/** Visitors passed to {@link walkAsync}. Shaped like {@link Visitors}, with awaitable handlers. */
+type AsyncVisitors<S = unknown> = { [K in NodeType]?: AsyncVisitor<NodeOfType<K>, S> } & { [K in keyof AliasMap]?: AsyncVisitor<AliasMap[K], S> } & {
+  enter?: AsyncVisitFn<Node, S>;
+  leave?: AsyncVisitFn<Node, S>;
+};
+//#endregion
+//#region src/aliases.d.ts
+/**
+ * Node types grouped under a shared alias. A visitor registered under an alias
+ * name runs for every member type. Membership is by node `type`.
+ */
+declare const ALIAS_GROUPS: {
+  readonly Expression: readonly ["Identifier", "Literal", "ThisExpression", "Super", "ArrayExpression", "ObjectExpression", "FunctionExpression", "ArrowFunctionExpression", "ClassExpression", "TaggedTemplateExpression", "TemplateLiteral", "MemberExpression", "CallExpression", "NewExpression", "ChainExpression", "SequenceExpression", "ParenthesizedExpression", "BinaryExpression", "LogicalExpression", "ConditionalExpression", "UnaryExpression", "UpdateExpression", "AssignmentExpression", "YieldExpression", "AwaitExpression", "ImportExpression", "MetaProperty", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression", "TSInstantiationExpression", "JSXElement", "JSXFragment"];
+  readonly Statement: readonly ["ExpressionStatement", "BlockStatement", "EmptyStatement", "DebuggerStatement", "ReturnStatement", "LabeledStatement", "BreakStatement", "ContinueStatement", "IfStatement", "SwitchStatement", "ThrowStatement", "TryStatement", "WhileStatement", "DoWhileStatement", "ForStatement", "ForInStatement", "ForOfStatement", "WithStatement", "FunctionDeclaration", "ClassDeclaration", "VariableDeclaration", "TSDeclareFunction", "TSTypeAliasDeclaration", "TSInterfaceDeclaration", "TSEnumDeclaration", "TSModuleDeclaration", "TSImportEqualsDeclaration"];
+  readonly Declaration: readonly ["FunctionDeclaration", "ClassDeclaration", "VariableDeclaration", "TSDeclareFunction", "TSTypeAliasDeclaration", "TSInterfaceDeclaration", "TSEnumDeclaration", "TSModuleDeclaration", "TSImportEqualsDeclaration"];
+  readonly ModuleDeclaration: readonly ["ImportDeclaration", "ExportNamedDeclaration", "ExportDefaultDeclaration", "ExportAllDeclaration", "TSExportAssignment", "TSNamespaceExportDeclaration"];
+  readonly Function: readonly ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression", "TSDeclareFunction", "TSEmptyBodyFunctionExpression"];
+  readonly Class: readonly ["ClassDeclaration", "ClassExpression"];
+  readonly Method: readonly ["MethodDefinition", "TSAbstractMethodDefinition"];
+  readonly Loop: readonly ["ForStatement", "ForInStatement", "ForOfStatement", "WhileStatement", "DoWhileStatement"];
+  readonly Pattern: readonly ["Identifier", "ArrayPattern", "ObjectPattern", "AssignmentPattern", "RestElement"];
+  readonly JSX: readonly ["JSXElement", "JSXOpeningElement", "JSXClosingElement", "JSXFragment", "JSXOpeningFragment", "JSXClosingFragment", "JSXIdentifier", "JSXNamespacedName", "JSXMemberExpression", "JSXAttribute", "JSXSpreadAttribute", "JSXExpressionContainer", "JSXEmptyExpression", "JSXText", "JSXSpreadChild"];
+  readonly TSType: readonly ["TSAnyKeyword", "TSUnknownKeyword", "TSNeverKeyword", "TSVoidKeyword", "TSNullKeyword", "TSUndefinedKeyword", "TSStringKeyword", "TSNumberKeyword", "TSBigIntKeyword", "TSBooleanKeyword", "TSSymbolKeyword", "TSObjectKeyword", "TSIntrinsicKeyword", "TSThisType", "TSTypeReference", "TSTypeQuery", "TSImportType", "TSLiteralType", "TSTemplateLiteralType", "TSArrayType", "TSIndexedAccessType", "TSTupleType", "TSNamedTupleMember", "TSJSDocNullableType", "TSJSDocNonNullableType", "TSJSDocUnknownType", "TSUnionType", "TSIntersectionType", "TSConditionalType", "TSInferType", "TSTypeOperator", "TSParenthesizedType", "TSFunctionType", "TSConstructorType", "TSTypePredicate", "TSTypeLiteral", "TSMappedType"];
+};
+/** Name of an alias group. */
+type AliasName = keyof typeof ALIAS_GROUPS;
+/** Node union matched by each alias group. */
+type AliasMap = { [K in AliasName]: NodeOfType<(typeof ALIAS_GROUPS)[K][number]> };
+//#endregion
+//#region src/predicates.d.ts
+type MaybeNode = Node | null | undefined;
+declare const is: {
+  Expression: (node: MaybeNode) => node is NodeOfType<"Identifier" | "Literal" | "ThisExpression" | "Super" | "ArrayExpression" | "ObjectExpression" | "FunctionExpression" | "ArrowFunctionExpression" | "ClassExpression" | "TaggedTemplateExpression" | "TemplateLiteral" | "MemberExpression" | "CallExpression" | "NewExpression" | "ChainExpression" | "SequenceExpression" | "ParenthesizedExpression" | "BinaryExpression" | "LogicalExpression" | "ConditionalExpression" | "UnaryExpression" | "UpdateExpression" | "AssignmentExpression" | "YieldExpression" | "AwaitExpression" | "ImportExpression" | "MetaProperty" | "TSAsExpression" | "TSSatisfiesExpression" | "TSTypeAssertion" | "TSNonNullExpression" | "TSInstantiationExpression" | "JSXElement" | "JSXFragment">;
+  Statement: (node: MaybeNode) => node is AliasMap["Statement"];
+  Declaration: (node: MaybeNode) => node is AliasMap["Declaration"];
+  ModuleDeclaration: (node: MaybeNode) => node is AliasMap["ModuleDeclaration"];
+  Function: (node: MaybeNode) => node is AliasMap["Function"];
+  Class: (node: MaybeNode) => node is AliasMap["Class"];
+  Method: (node: MaybeNode) => node is AliasMap["Method"];
+  Loop: (node: MaybeNode) => node is AliasMap["Loop"];
+  Pattern: (node: MaybeNode) => node is AliasMap["Pattern"];
+  JSX: (node: MaybeNode) => node is AliasMap["JSX"];
+  TSType: (node: MaybeNode) => node is AliasMap["TSType"];
+  IdentifierReference: (node: MaybeNode) => node is IdentifierReference;
+  BindingIdentifier: (node: MaybeNode) => node is BindingIdentifier;
+  LabelIdentifier: (node: MaybeNode) => node is LabelIdentifier;
+  IdentifierName: (node: MaybeNode) => node is IdentifierName;
+  StringLiteral: (node: MaybeNode) => node is StringLiteral;
+  NumericLiteral: (node: MaybeNode) => node is NumericLiteral;
+  BooleanLiteral: (node: MaybeNode) => node is BooleanLiteral;
+  NullLiteral: (node: MaybeNode) => node is NullLiteral;
+  BigIntLiteral: (node: MaybeNode) => node is BigIntLiteral;
+  RegExpLiteral: (node: MaybeNode) => node is RegExpLiteral;
+  ComputedMemberExpression: (node: MaybeNode) => node is ComputedMemberExpression;
+  StaticMemberExpression: (node: MaybeNode) => node is StaticMemberExpression;
+  PrivateFieldExpression: (node: MaybeNode) => node is PrivateFieldExpression;
+  Directive: (node: MaybeNode) => node is Directive;
+  Program: (node: MaybeNode) => node is import("yuku-parser").Program;
+  Hashbang: (node: MaybeNode) => node is import("yuku-parser").Hashbang;
+  ExpressionStatement: (node: MaybeNode) => node is NodeOfType<"ExpressionStatement">;
+  BlockStatement: (node: MaybeNode) => node is import("yuku-parser").BlockStatement;
+  EmptyStatement: (node: MaybeNode) => node is import("yuku-parser").EmptyStatement;
+  DebuggerStatement: (node: MaybeNode) => node is import("yuku-parser").DebuggerStatement;
+  ReturnStatement: (node: MaybeNode) => node is import("yuku-parser").ReturnStatement;
+  LabeledStatement: (node: MaybeNode) => node is import("yuku-parser").LabeledStatement;
+  BreakStatement: (node: MaybeNode) => node is import("yuku-parser").BreakStatement;
+  ContinueStatement: (node: MaybeNode) => node is import("yuku-parser").ContinueStatement;
+  IfStatement: (node: MaybeNode) => node is import("yuku-parser").IfStatement;
+  SwitchStatement: (node: MaybeNode) => node is import("yuku-parser").SwitchStatement;
+  ThrowStatement: (node: MaybeNode) => node is import("yuku-parser").ThrowStatement;
+  TryStatement: (node: MaybeNode) => node is import("yuku-parser").TryStatement;
+  WhileStatement: (node: MaybeNode) => node is import("yuku-parser").WhileStatement;
+  DoWhileStatement: (node: MaybeNode) => node is import("yuku-parser").DoWhileStatement;
+  ForStatement: (node: MaybeNode) => node is import("yuku-parser").ForStatement;
+  ForInStatement: (node: MaybeNode) => node is import("yuku-parser").ForInStatement;
+  ForOfStatement: (node: MaybeNode) => node is import("yuku-parser").ForOfStatement;
+  WithStatement: (node: MaybeNode) => node is import("yuku-parser").WithStatement;
+  FunctionDeclaration: (node: MaybeNode) => node is import("yuku-parser").FunctionDeclaration;
+  ClassDeclaration: (node: MaybeNode) => node is import("yuku-parser").ClassDeclaration;
+  VariableDeclaration: (node: MaybeNode) => node is import("yuku-parser").VariableDeclaration;
+  TSDeclareFunction: (node: MaybeNode) => node is import("yuku-parser").TSDeclareFunction;
+  TSTypeAliasDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSTypeAliasDeclaration;
+  TSInterfaceDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSInterfaceDeclaration;
+  TSEnumDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSEnumDeclaration;
+  TSModuleDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSModuleDeclaration;
+  TSImportEqualsDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSImportEqualsDeclaration;
+  Identifier: (node: MaybeNode) => node is import("yuku-parser").Identifier;
+  Literal: (node: MaybeNode) => node is NodeOfType<"Literal">;
+  ThisExpression: (node: MaybeNode) => node is import("yuku-parser").ThisExpression;
+  Super: (node: MaybeNode) => node is import("yuku-parser").Super;
+  ArrayExpression: (node: MaybeNode) => node is import("yuku-parser").ArrayExpression;
+  ObjectExpression: (node: MaybeNode) => node is import("yuku-parser").ObjectExpression;
+  FunctionExpression: (node: MaybeNode) => node is import("yuku-parser").FunctionExpression;
+  ArrowFunctionExpression: (node: MaybeNode) => node is import("yuku-parser").ArrowFunctionExpression;
+  ClassExpression: (node: MaybeNode) => node is import("yuku-parser").ClassExpression;
+  TaggedTemplateExpression: (node: MaybeNode) => node is import("yuku-parser").TaggedTemplateExpression;
+  TemplateLiteral: (node: MaybeNode) => node is import("yuku-parser").TemplateLiteral;
+  MemberExpression: (node: MaybeNode) => node is NodeOfType<"MemberExpression">;
+  CallExpression: (node: MaybeNode) => node is import("yuku-parser").CallExpression;
+  NewExpression: (node: MaybeNode) => node is import("yuku-parser").NewExpression;
+  ChainExpression: (node: MaybeNode) => node is import("yuku-parser").ChainExpression;
+  SequenceExpression: (node: MaybeNode) => node is import("yuku-parser").SequenceExpression;
+  ParenthesizedExpression: (node: MaybeNode) => node is import("yuku-parser").ParenthesizedExpression;
+  BinaryExpression: (node: MaybeNode) => node is import("yuku-parser").BinaryExpression;
+  LogicalExpression: (node: MaybeNode) => node is import("yuku-parser").LogicalExpression;
+  ConditionalExpression: (node: MaybeNode) => node is import("yuku-parser").ConditionalExpression;
+  UnaryExpression: (node: MaybeNode) => node is import("yuku-parser").UnaryExpression;
+  UpdateExpression: (node: MaybeNode) => node is import("yuku-parser").UpdateExpression;
+  AssignmentExpression: (node: MaybeNode) => node is import("yuku-parser").AssignmentExpression;
+  YieldExpression: (node: MaybeNode) => node is import("yuku-parser").YieldExpression;
+  AwaitExpression: (node: MaybeNode) => node is import("yuku-parser").AwaitExpression;
+  ImportExpression: (node: MaybeNode) => node is import("yuku-parser").ImportExpression;
+  MetaProperty: (node: MaybeNode) => node is import("yuku-parser").MetaProperty;
+  TSAsExpression: (node: MaybeNode) => node is import("yuku-parser").TSAsExpression;
+  TSSatisfiesExpression: (node: MaybeNode) => node is import("yuku-parser").TSSatisfiesExpression;
+  TSTypeAssertion: (node: MaybeNode) => node is import("yuku-parser").TSTypeAssertion;
+  TSNonNullExpression: (node: MaybeNode) => node is import("yuku-parser").TSNonNullExpression;
+  TSInstantiationExpression: (node: MaybeNode) => node is import("yuku-parser").TSInstantiationExpression;
+  JSXElement: (node: MaybeNode) => node is import("yuku-parser").JSXElement;
+  JSXFragment: (node: MaybeNode) => node is import("yuku-parser").JSXFragment;
+  ImportDeclaration: (node: MaybeNode) => node is import("yuku-parser").ImportDeclaration;
+  ExportNamedDeclaration: (node: MaybeNode) => node is import("yuku-parser").ExportNamedDeclaration;
+  ExportDefaultDeclaration: (node: MaybeNode) => node is import("yuku-parser").ExportDefaultDeclaration;
+  ExportAllDeclaration: (node: MaybeNode) => node is import("yuku-parser").ExportAllDeclaration;
+  TSExportAssignment: (node: MaybeNode) => node is import("yuku-parser").TSExportAssignment;
+  TSNamespaceExportDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSNamespaceExportDeclaration;
+  Property: (node: MaybeNode) => node is NodeOfType<"Property">;
+  SpreadElement: (node: MaybeNode) => node is import("yuku-parser").SpreadElement;
+  PrivateIdentifier: (node: MaybeNode) => node is import("yuku-parser").PrivateIdentifier;
+  TemplateElement: (node: MaybeNode) => node is import("yuku-parser").TemplateElement;
+  VariableDeclarator: (node: MaybeNode) => node is import("yuku-parser").VariableDeclarator;
+  CatchClause: (node: MaybeNode) => node is import("yuku-parser").CatchClause;
+  SwitchCase: (node: MaybeNode) => node is import("yuku-parser").SwitchCase;
+  RestElement: (node: MaybeNode) => node is import("yuku-parser").RestElement;
+  ArrayPattern: (node: MaybeNode) => node is import("yuku-parser").ArrayPattern;
+  ObjectPattern: (node: MaybeNode) => node is import("yuku-parser").ObjectPattern;
+  AssignmentPattern: (node: MaybeNode) => node is import("yuku-parser").AssignmentPattern;
+  ClassBody: (node: MaybeNode) => node is import("yuku-parser").ClassBody;
+  MethodDefinition: (node: MaybeNode) => node is import("yuku-parser").MethodDefinition;
+  TSAbstractMethodDefinition: (node: MaybeNode) => node is import("yuku-parser").TSAbstractMethodDefinition;
+  PropertyDefinition: (node: MaybeNode) => node is import("yuku-parser").PropertyDefinition;
+  TSAbstractPropertyDefinition: (node: MaybeNode) => node is import("yuku-parser").TSAbstractPropertyDefinition;
+  AccessorProperty: (node: MaybeNode) => node is import("yuku-parser").AccessorProperty;
+  TSAbstractAccessorProperty: (node: MaybeNode) => node is import("yuku-parser").TSAbstractAccessorProperty;
+  StaticBlock: (node: MaybeNode) => node is import("yuku-parser").StaticBlock;
+  Decorator: (node: MaybeNode) => node is import("yuku-parser").Decorator;
+  TSEmptyBodyFunctionExpression: (node: MaybeNode) => node is import("yuku-parser").TSEmptyBodyFunctionExpression;
+  ImportSpecifier: (node: MaybeNode) => node is import("yuku-parser").ImportSpecifier;
+  ImportDefaultSpecifier: (node: MaybeNode) => node is import("yuku-parser").ImportDefaultSpecifier;
+  ImportNamespaceSpecifier: (node: MaybeNode) => node is import("yuku-parser").ImportNamespaceSpecifier;
+  ImportAttribute: (node: MaybeNode) => node is import("yuku-parser").ImportAttribute;
+  ExportSpecifier: (node: MaybeNode) => node is import("yuku-parser").ExportSpecifier;
+  JSXOpeningElement: (node: MaybeNode) => node is import("yuku-parser").JSXOpeningElement;
+  JSXClosingElement: (node: MaybeNode) => node is import("yuku-parser").JSXClosingElement;
+  JSXOpeningFragment: (node: MaybeNode) => node is import("yuku-parser").JSXOpeningFragment;
+  JSXClosingFragment: (node: MaybeNode) => node is import("yuku-parser").JSXClosingFragment;
+  JSXIdentifier: (node: MaybeNode) => node is import("yuku-parser").JSXIdentifier;
+  JSXNamespacedName: (node: MaybeNode) => node is import("yuku-parser").JSXNamespacedName;
+  JSXMemberExpression: (node: MaybeNode) => node is import("yuku-parser").JSXMemberExpression;
+  JSXAttribute: (node: MaybeNode) => node is import("yuku-parser").JSXAttribute;
+  JSXSpreadAttribute: (node: MaybeNode) => node is import("yuku-parser").JSXSpreadAttribute;
+  JSXExpressionContainer: (node: MaybeNode) => node is import("yuku-parser").JSXExpressionContainer;
+  JSXEmptyExpression: (node: MaybeNode) => node is import("yuku-parser").JSXEmptyExpression;
+  JSXText: (node: MaybeNode) => node is import("yuku-parser").JSXText;
+  JSXSpreadChild: (node: MaybeNode) => node is import("yuku-parser").JSXSpreadChild;
+  TSTypeAnnotation: (node: MaybeNode) => node is import("yuku-parser").TSTypeAnnotation;
+  TSAnyKeyword: (node: MaybeNode) => node is import("yuku-parser").TSAnyKeyword;
+  TSUnknownKeyword: (node: MaybeNode) => node is import("yuku-parser").TSUnknownKeyword;
+  TSNeverKeyword: (node: MaybeNode) => node is import("yuku-parser").TSNeverKeyword;
+  TSVoidKeyword: (node: MaybeNode) => node is import("yuku-parser").TSVoidKeyword;
+  TSNullKeyword: (node: MaybeNode) => node is import("yuku-parser").TSNullKeyword;
+  TSUndefinedKeyword: (node: MaybeNode) => node is import("yuku-parser").TSUndefinedKeyword;
+  TSStringKeyword: (node: MaybeNode) => node is import("yuku-parser").TSStringKeyword;
+  TSNumberKeyword: (node: MaybeNode) => node is import("yuku-parser").TSNumberKeyword;
+  TSBigIntKeyword: (node: MaybeNode) => node is import("yuku-parser").TSBigIntKeyword;
+  TSBooleanKeyword: (node: MaybeNode) => node is import("yuku-parser").TSBooleanKeyword;
+  TSSymbolKeyword: (node: MaybeNode) => node is import("yuku-parser").TSSymbolKeyword;
+  TSObjectKeyword: (node: MaybeNode) => node is import("yuku-parser").TSObjectKeyword;
+  TSIntrinsicKeyword: (node: MaybeNode) => node is import("yuku-parser").TSIntrinsicKeyword;
+  TSThisType: (node: MaybeNode) => node is import("yuku-parser").TSThisType;
+  TSTypeReference: (node: MaybeNode) => node is import("yuku-parser").TSTypeReference;
+  TSTypeQuery: (node: MaybeNode) => node is import("yuku-parser").TSTypeQuery;
+  TSImportType: (node: MaybeNode) => node is import("yuku-parser").TSImportType;
+  TSLiteralType: (node: MaybeNode) => node is import("yuku-parser").TSLiteralType;
+  TSTemplateLiteralType: (node: MaybeNode) => node is import("yuku-parser").TSTemplateLiteralType;
+  TSArrayType: (node: MaybeNode) => node is import("yuku-parser").TSArrayType;
+  TSIndexedAccessType: (node: MaybeNode) => node is import("yuku-parser").TSIndexedAccessType;
+  TSTupleType: (node: MaybeNode) => node is import("yuku-parser").TSTupleType;
+  TSNamedTupleMember: (node: MaybeNode) => node is import("yuku-parser").TSNamedTupleMember;
+  TSJSDocNullableType: (node: MaybeNode) => node is import("yuku-parser").TSJSDocNullableType;
+  TSJSDocNonNullableType: (node: MaybeNode) => node is import("yuku-parser").TSJSDocNonNullableType;
+  TSJSDocUnknownType: (node: MaybeNode) => node is import("yuku-parser").TSJSDocUnknownType;
+  TSUnionType: (node: MaybeNode) => node is import("yuku-parser").TSUnionType;
+  TSIntersectionType: (node: MaybeNode) => node is import("yuku-parser").TSIntersectionType;
+  TSConditionalType: (node: MaybeNode) => node is import("yuku-parser").TSConditionalType;
+  TSInferType: (node: MaybeNode) => node is import("yuku-parser").TSInferType;
+  TSTypeOperator: (node: MaybeNode) => node is import("yuku-parser").TSTypeOperator;
+  TSParenthesizedType: (node: MaybeNode) => node is import("yuku-parser").TSParenthesizedType;
+  TSFunctionType: (node: MaybeNode) => node is import("yuku-parser").TSFunctionType;
+  TSConstructorType: (node: MaybeNode) => node is import("yuku-parser").TSConstructorType;
+  TSTypePredicate: (node: MaybeNode) => node is import("yuku-parser").TSTypePredicate;
+  TSTypeLiteral: (node: MaybeNode) => node is import("yuku-parser").TSTypeLiteral;
+  TSMappedType: (node: MaybeNode) => node is import("yuku-parser").TSMappedType;
+  TSTypeParameter: (node: MaybeNode) => node is import("yuku-parser").TSTypeParameter;
+  TSTypeParameterDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSTypeParameterDeclaration;
+  TSTypeParameterInstantiation: (node: MaybeNode) => node is import("yuku-parser").TSTypeParameterInstantiation;
+  TSQualifiedName: (node: MaybeNode) => node is import("yuku-parser").TSQualifiedName;
+  TSPropertySignature: (node: MaybeNode) => node is import("yuku-parser").TSPropertySignature;
+  TSMethodSignature: (node: MaybeNode) => node is import("yuku-parser").TSMethodSignature;
+  TSCallSignatureDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSCallSignatureDeclaration;
+  TSConstructSignatureDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSConstructSignatureDeclaration;
+  TSIndexSignature: (node: MaybeNode) => node is import("yuku-parser").TSIndexSignature;
+  TSInterfaceBody: (node: MaybeNode) => node is import("yuku-parser").TSInterfaceBody;
+  TSInterfaceHeritage: (node: MaybeNode) => node is import("yuku-parser").TSInterfaceHeritage;
+  TSClassImplements: (node: MaybeNode) => node is import("yuku-parser").TSClassImplements;
+  TSEnumBody: (node: MaybeNode) => node is import("yuku-parser").TSEnumBody;
+  TSEnumMember: (node: MaybeNode) => node is import("yuku-parser").TSEnumMember;
+  TSModuleBlock: (node: MaybeNode) => node is import("yuku-parser").TSModuleBlock;
+  TSParameterProperty: (node: MaybeNode) => node is import("yuku-parser").TSParameterProperty;
+  TSExternalModuleReference: (node: MaybeNode) => node is import("yuku-parser").TSExternalModuleReference;
+  TSOptionalType: (node: MaybeNode) => node is import("yuku-parser").TSOptionalType;
+  TSRestType: (node: MaybeNode) => node is import("yuku-parser").TSRestType;
+};
+//#endregion
+//#region src/builders.d.ts
+declare const b: {
+  identifier(name: string, kind?: t.IdentifierKind, opts?: {
+    typeAnnotation?: t.TSTypeAnnotation | null;
+    optional?: boolean;
+    decorators?: t.Decorator[];
+  }): t.Identifier;
+  privateIdentifier(name: string): t.PrivateIdentifier;
+  stringLiteral(value: string): t.StringLiteral;
+  numericLiteral(value: number): t.NumericLiteral;
+  booleanLiteral(value: boolean): t.BooleanLiteral;
+  nullLiteral(): t.NullLiteral;
+  bigIntLiteral(value: bigint): t.BigIntLiteral;
+  regExpLiteral(pattern: string, flags?: string): t.RegExpLiteral;
+  templateLiteral(quasis: t.TemplateElement[], expressions: t.Expression[]): t.TemplateLiteral;
+  templateElement(cooked: string, tail?: boolean): t.TemplateElement;
+  thisExpression(): t.ThisExpression;
+  super(): t.Super;
+  arrayPattern(elements: Array<t.BindingPattern | t.RestElement | null>): t.ArrayPattern;
+  objectPattern(properties: Array<t.BindingProperty | t.RestElement>): t.ObjectPattern;
+  assignmentPattern(left: t.BindingPattern, right: t.Expression): t.AssignmentPattern;
+  restElement(argument: t.BindingPattern): t.RestElement; /** A member of an `ObjectExpression`. For an `ObjectPattern` member, use {@link bindingProperty}. */
+  objectProperty(key: t.PropertyKey, value: t.Expression, opts?: {
+    computed?: boolean;
+    shorthand?: boolean;
+    kind?: t.PropertyKind;
+    method?: boolean;
+  }): t.ObjectProperty; /** A member of an `ObjectPattern`, whose value is a binding target. For an `ObjectExpression` member, use {@link objectProperty}. */
+  bindingProperty(key: t.PropertyKey, value: t.BindingPattern, opts?: {
+    computed?: boolean;
+    shorthand?: boolean;
+  }): t.BindingProperty;
+  arrayExpression(elements?: t.ArrayExpressionElement[]): t.ArrayExpression;
+  objectExpression(properties?: t.ObjectPropertyKind[]): t.ObjectExpression;
+  spreadElement(argument: t.Expression): t.SpreadElement;
+  sequenceExpression(expressions: t.Expression[]): t.SequenceExpression;
+  parenthesizedExpression(expression: t.Expression): t.ParenthesizedExpression;
+  unaryExpression(operator: t.UnaryOperator, argument: t.Expression): t.UnaryExpression;
+  updateExpression(operator: t.UpdateOperator, argument: t.Expression, prefix?: boolean): t.UpdateExpression;
+  binaryExpression(operator: t.BinaryOperator, left: t.Expression | t.PrivateIdentifier, right: t.Expression): t.BinaryExpression;
+  logicalExpression(operator: t.LogicalOperator, left: t.Expression, right: t.Expression): t.LogicalExpression;
+  assignmentExpression(operator: t.AssignmentOperator, left: t.AssignmentTarget, right: t.Expression): t.AssignmentExpression;
+  conditionalExpression(test: t.Expression, consequent: t.Expression, alternate: t.Expression): t.ConditionalExpression;
+  yieldExpression(argument?: t.Expression | null, delegate?: boolean): t.YieldExpression;
+  awaitExpression(argument: t.Expression): t.AwaitExpression;
+  memberExpression(object: t.Expression | t.Super, property: t.Expression | t.IdentifierName | t.PrivateIdentifier, opts?: {
+    computed?: boolean;
+    optional?: boolean;
+  }): t.MemberExpression;
+  callExpression(callee: t.Expression | t.Super, args?: t.Argument[], opts?: {
+    optional?: boolean;
+    typeArguments?: t.TSTypeParameterInstantiation | null;
+  }): t.CallExpression;
+  newExpression(callee: t.Expression, args?: t.Argument[], opts?: {
+    typeArguments?: t.TSTypeParameterInstantiation | null;
+  }): t.NewExpression;
+  chainExpression(expression: t.ChainElement): t.ChainExpression;
+  taggedTemplateExpression(tag: t.Expression, quasi: t.TemplateLiteral, opts?: {
+    typeArguments?: t.TSTypeParameterInstantiation | null;
+  }): t.TaggedTemplateExpression;
+  metaProperty(meta: string, property: string): t.MetaProperty;
+  importExpression(source: t.Expression, opts?: {
+    options?: t.Expression | null;
+    phase?: t.ImportPhase | null;
+  }): t.ImportExpression;
+  arrowFunctionExpression(params: t.FunctionParameter[], body: t.BlockStatement | t.Expression, opts?: {
+    async?: boolean;
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+    returnType?: t.TSTypeAnnotation | null;
+  }): t.ArrowFunctionExpression;
+  functionExpression(params: t.FunctionParameter[], body: t.BlockStatement, opts?: {
+    id?: t.Identifier | null;
+    async?: boolean;
+    generator?: boolean;
+  }): t.FunctionExpression;
+  functionDeclaration(id: t.Identifier | null, params: t.FunctionParameter[], body: t.BlockStatement | null, opts?: {
+    async?: boolean;
+    generator?: boolean;
+  }): t.FunctionDeclaration;
+  classDeclaration(id: t.Identifier | null, body: t.ClassBody, opts?: {
+    superClass?: t.Expression | null;
+    decorators?: t.Decorator[];
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+    abstract?: boolean;
+  }): t.ClassDeclaration;
+  classExpression(id: t.Identifier | null, body: t.ClassBody, opts?: {
+    superClass?: t.Expression | null;
+    decorators?: t.Decorator[];
+  }): t.ClassExpression;
+  classBody(body?: t.ClassElement[]): t.ClassBody;
+  methodDefinition(key: t.PropertyKey, value: t.FunctionExpression | t.TSEmptyBodyFunctionExpression, opts?: {
+    kind?: t.MethodDefinitionKind;
+    computed?: boolean;
+    static?: boolean;
+  }): t.MethodDefinition;
+  propertyDefinition(key: t.PropertyKey, value?: t.Expression | null, opts?: {
+    computed?: boolean;
+    static?: boolean;
+    decorators?: t.Decorator[];
+  }): t.PropertyDefinition;
+  accessorProperty(key: t.PropertyKey, value?: t.Expression | null, opts?: {
+    computed?: boolean;
+    static?: boolean;
+  }): t.AccessorProperty;
+  tsAbstractMethodDefinition(key: t.PropertyKey, value: t.FunctionExpression | t.TSEmptyBodyFunctionExpression, opts?: {
+    kind?: t.MethodDefinitionKind;
+    computed?: boolean;
+    static?: boolean;
+  }): t.TSAbstractMethodDefinition;
+  tsAbstractPropertyDefinition(key: t.PropertyKey, value?: t.Expression | null, opts?: {
+    computed?: boolean;
+    static?: boolean;
+  }): t.TSAbstractPropertyDefinition;
+  tsAbstractAccessorProperty(key: t.PropertyKey, value?: t.Expression | null, opts?: {
+    computed?: boolean;
+    static?: boolean;
+  }): t.TSAbstractAccessorProperty;
+  staticBlock(body?: t.Statement[]): t.StaticBlock;
+  decorator(expression: t.Expression): t.Decorator;
+  expressionStatement(expression: t.Expression): t.ExpressionStatement;
+  directive(value: string): t.Directive;
+  blockStatement(body?: t.Statement[]): t.BlockStatement;
+  emptyStatement(): t.EmptyStatement;
+  debuggerStatement(): t.DebuggerStatement;
+  returnStatement(argument?: t.Expression | null): t.ReturnStatement;
+  ifStatement(test: t.Expression, consequent: t.Statement, alternate?: t.Statement | null): t.IfStatement;
+  switchStatement(discriminant: t.Expression, cases: t.SwitchCase[]): t.SwitchStatement;
+  switchCase(test: t.Expression | null, consequent: t.Statement[]): t.SwitchCase;
+  throwStatement(argument: t.Expression): t.ThrowStatement;
+  tryStatement(block: t.BlockStatement, handler?: t.CatchClause | null, finalizer?: t.BlockStatement | null): t.TryStatement;
+  catchClause(param: t.BindingPattern | null, body: t.BlockStatement): t.CatchClause;
+  whileStatement(test: t.Expression, body: t.Statement): t.WhileStatement;
+  doWhileStatement(body: t.Statement, test: t.Expression): t.DoWhileStatement;
+  forStatement(init: t.ForStatementInit | null, test: t.Expression | null, update: t.Expression | null, body: t.Statement): t.ForStatement;
+  forInStatement(left: t.ForStatementLeft, right: t.Expression, body: t.Statement): t.ForInStatement;
+  forOfStatement(left: t.ForStatementLeft, right: t.Expression, body: t.Statement, isAwait?: boolean): t.ForOfStatement;
+  labeledStatement(label: t.LabelIdentifier, body: t.Statement): t.LabeledStatement;
+  breakStatement(label?: t.LabelIdentifier | null): t.BreakStatement;
+  continueStatement(label?: t.LabelIdentifier | null): t.ContinueStatement;
+  withStatement(object: t.Expression, body: t.Statement): t.WithStatement;
+  variableDeclaration(kind: t.VariableDeclarationKind, declarations: t.VariableDeclarator[]): t.VariableDeclaration;
+  variableDeclarator(id: t.BindingPattern, init?: t.Expression | null): t.VariableDeclarator;
+  importDeclaration(specifiers: t.ImportDeclarationSpecifier[], source: t.StringLiteral, opts?: {
+    attributes?: t.ImportAttribute[];
+    phase?: t.ImportPhase | null;
+    importKind?: t.ImportOrExportKind;
+  }): t.ImportDeclaration;
+  importSpecifier(imported: t.IdentifierName | t.StringLiteral, local: t.BindingIdentifier): t.ImportSpecifier;
+  importDefaultSpecifier(local: t.BindingIdentifier): t.ImportDefaultSpecifier;
+  importNamespaceSpecifier(local: t.BindingIdentifier): t.ImportNamespaceSpecifier;
+  importAttribute(key: t.ImportAttributeKey, value: t.StringLiteral): t.ImportAttribute;
+  exportNamedDeclaration(declaration: t.Declaration | null, specifiers?: t.ExportSpecifier[], opts?: {
+    source?: t.StringLiteral | null;
+    attributes?: t.ImportAttribute[];
+    exportKind?: t.ImportOrExportKind;
+  }): t.ExportNamedDeclaration;
+  exportDefaultDeclaration(declaration: t.ExportDefaultDeclarationKind): t.ExportDefaultDeclaration;
+  exportAllDeclaration(source: t.StringLiteral, opts?: {
+    exported?: t.ModuleExportName | null;
+    attributes?: t.ImportAttribute[];
+    exportKind?: t.ImportOrExportKind;
+  }): t.ExportAllDeclaration;
+  exportSpecifier(local: t.ModuleExportName, exported: t.ModuleExportName): t.ExportSpecifier;
+  jsxIdentifier(name: string): t.JSXIdentifier;
+  jsxNamespacedName(namespace: t.JSXIdentifier, name: t.JSXIdentifier): t.JSXNamespacedName;
+  jsxMemberExpression(object: t.JSXMemberExpressionObject, property: t.JSXIdentifier): t.JSXMemberExpression;
+  jsxElement(openingElement: t.JSXOpeningElement, children?: t.JSXChild[], closingElement?: t.JSXClosingElement | null): t.JSXElement;
+  jsxOpeningElement(name: t.JSXElementName, attributes?: t.JSXAttributeItem[], selfClosing?: boolean): t.JSXOpeningElement;
+  jsxClosingElement(name: t.JSXElementName): t.JSXClosingElement;
+  jsxOpeningFragment(): t.JSXOpeningFragment;
+  jsxClosingFragment(): t.JSXClosingFragment;
+  jsxFragment(children?: t.JSXChild[]): t.JSXFragment;
+  jsxAttribute(name: t.JSXAttributeName, value?: t.JSXAttributeValue | null): t.JSXAttribute;
+  jsxSpreadAttribute(argument: t.Expression): t.JSXSpreadAttribute;
+  jsxExpressionContainer(expression: t.JSXExpression): t.JSXExpressionContainer;
+  jsxEmptyExpression(): t.JSXEmptyExpression;
+  jsxText(value: string): t.JSXText;
+  jsxSpreadChild(expression: t.Expression): t.JSXSpreadChild;
+  tsTypeAnnotation(typeAnnotation: t.TSType): t.TSTypeAnnotation;
+  tsAnyKeyword: () => t.TSAnyKeyword;
+  tsUnknownKeyword: () => t.TSUnknownKeyword;
+  tsNeverKeyword: () => t.TSNeverKeyword;
+  tsVoidKeyword: () => t.TSVoidKeyword;
+  tsNullKeyword: () => t.TSNullKeyword;
+  tsUndefinedKeyword: () => t.TSUndefinedKeyword;
+  tsStringKeyword: () => t.TSStringKeyword;
+  tsNumberKeyword: () => t.TSNumberKeyword;
+  tsBigIntKeyword: () => t.TSBigIntKeyword;
+  tsBooleanKeyword: () => t.TSBooleanKeyword;
+  tsSymbolKeyword: () => t.TSSymbolKeyword;
+  tsObjectKeyword: () => t.TSObjectKeyword;
+  tsIntrinsicKeyword: () => t.TSIntrinsicKeyword;
+  tsThisType: () => t.TSThisType;
+  tsTypeReference(typeName: t.TSTypeName, typeArguments?: t.TSTypeParameterInstantiation | null): t.TSTypeReference;
+  tsQualifiedName(left: t.TSTypeName, right: t.IdentifierName): t.TSQualifiedName;
+  tsTypeQuery(exprName: t.TSTypeQueryExprName, typeArguments?: t.TSTypeParameterInstantiation | null): t.TSTypeQuery;
+  tsImportType(source: t.StringLiteral, opts?: {
+    options?: t.ObjectExpression | null;
+    qualifier?: t.TSImportTypeQualifier | null;
+    typeArguments?: t.TSTypeParameterInstantiation | null;
+  }): t.TSImportType;
+  tsTypeParameter(name: t.BindingIdentifier, opts?: {
+    constraint?: t.TSType | null;
+    default?: t.TSType | null;
+    in?: boolean;
+    out?: boolean;
+    const?: boolean;
+  }): t.TSTypeParameter;
+  tsTypeParameterDeclaration(params: t.TSTypeParameter[]): t.TSTypeParameterDeclaration;
+  tsTypeParameterInstantiation(params: t.TSType[]): t.TSTypeParameterInstantiation;
+  tsLiteralType(literal: t.TSLiteralType["literal"]): t.TSLiteralType;
+  tsTemplateLiteralType(quasis: t.TemplateElement[], types: t.TSType[]): t.TSTemplateLiteralType;
+  tsArrayType(elementType: t.TSType): t.TSArrayType;
+  tsIndexedAccessType(objectType: t.TSType, indexType: t.TSType): t.TSIndexedAccessType;
+  tsTupleType(elementTypes: t.TSTupleElement[]): t.TSTupleType;
+  tsNamedTupleMember(label: t.IdentifierName, elementType: t.TSType, optional?: boolean): t.TSNamedTupleMember;
+  tsOptionalType(typeAnnotation: t.TSType): t.TSOptionalType;
+  tsRestType(typeAnnotation: t.TSType | t.TSNamedTupleMember): t.TSRestType;
+  tsJSDocNullableType(typeAnnotation: t.TSType, postfix?: boolean): t.TSJSDocNullableType;
+  tsJSDocNonNullableType(typeAnnotation: t.TSType, postfix?: boolean): t.TSJSDocNonNullableType;
+  tsJSDocUnknownType(): t.TSJSDocUnknownType;
+  tsUnionType(types: t.TSType[]): t.TSUnionType;
+  tsIntersectionType(types: t.TSType[]): t.TSIntersectionType;
+  tsConditionalType(checkType: t.TSType, extendsType: t.TSType, trueType: t.TSType, falseType: t.TSType): t.TSConditionalType;
+  tsInferType(typeParameter: t.TSTypeParameter): t.TSInferType;
+  tsTypeOperator(operator: t.TSTypeOperator["operator"], typeAnnotation: t.TSType): t.TSTypeOperator;
+  tsParenthesizedType(typeAnnotation: t.TSType): t.TSParenthesizedType;
+  tsFunctionType(params: t.FunctionParameter[], returnType: t.TSTypeAnnotation | null, typeParameters?: t.TSTypeParameterDeclaration | null): t.TSFunctionType;
+  tsConstructorType(params: t.FunctionParameter[], returnType: t.TSTypeAnnotation | null, opts?: {
+    abstract?: boolean;
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+  }): t.TSConstructorType;
+  tsTypePredicate(parameterName: t.TSTypePredicateName, typeAnnotation?: t.TSTypeAnnotation | null, asserts?: boolean): t.TSTypePredicate;
+  tsTypeLiteral(members: t.TSSignature[]): t.TSTypeLiteral;
+  tsMappedType(key: t.BindingIdentifier, constraint: t.TSType, opts?: {
+    nameType?: t.TSType | null;
+    typeAnnotation?: t.TSType | null;
+    optional?: t.TSMappedTypeModifierOperator | false;
+    readonly?: t.TSMappedTypeModifierOperator | null;
+  }): t.TSMappedType;
+  tsPropertySignature(key: t.PropertyKey, opts?: {
+    typeAnnotation?: t.TSTypeAnnotation | null;
+    computed?: boolean;
+    optional?: boolean;
+    readonly?: boolean;
+  }): t.TSPropertySignature;
+  tsMethodSignature(key: t.PropertyKey, params: t.FunctionParameter[], opts?: {
+    kind?: t.TSMethodSignatureKind;
+    computed?: boolean;
+    optional?: boolean;
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+    returnType?: t.TSTypeAnnotation | null;
+  }): t.TSMethodSignature;
+  tsCallSignatureDeclaration(params: t.FunctionParameter[], returnType?: t.TSTypeAnnotation | null, typeParameters?: t.TSTypeParameterDeclaration | null): t.TSCallSignatureDeclaration;
+  tsConstructSignatureDeclaration(params: t.FunctionParameter[], returnType?: t.TSTypeAnnotation | null, typeParameters?: t.TSTypeParameterDeclaration | null): t.TSConstructSignatureDeclaration;
+  tsIndexSignature(parameters: t.BindingIdentifier[], typeAnnotation: t.TSTypeAnnotation, opts?: {
+    readonly?: boolean;
+    static?: boolean;
+  }): t.TSIndexSignature;
+  tsTypeAliasDeclaration(id: t.BindingIdentifier, typeAnnotation: t.TSType, opts?: {
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+    declare?: boolean;
+  }): t.TSTypeAliasDeclaration;
+  tsInterfaceDeclaration(id: t.BindingIdentifier, body: t.TSInterfaceBody, opts?: {
+    extends?: t.TSInterfaceHeritage[];
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+    declare?: boolean;
+  }): t.TSInterfaceDeclaration;
+  tsInterfaceBody(body: t.TSSignature[]): t.TSInterfaceBody;
+  tsInterfaceHeritage(expression: t.Expression, typeArguments?: t.TSTypeParameterInstantiation | null): t.TSInterfaceHeritage;
+  tsClassImplements(expression: t.Expression, typeArguments?: t.TSTypeParameterInstantiation | null): t.TSClassImplements;
+  tsEnumDeclaration(id: t.BindingIdentifier, body: t.TSEnumBody, opts?: {
+    const?: boolean;
+    declare?: boolean;
+  }): t.TSEnumDeclaration;
+  tsEnumBody(members: t.TSEnumMember[]): t.TSEnumBody;
+  tsEnumMember(id: t.TSEnumMemberName, initializer?: t.Expression | null): t.TSEnumMember;
+  tsModuleDeclaration(id: t.TSModuleDeclaration["id"], body: t.TSModuleBlock | undefined, opts?: {
+    kind?: t.TSModuleDeclarationKind;
+    declare?: boolean;
+    global?: boolean;
+  }): t.TSModuleDeclaration;
+  tsModuleBlock(body?: t.Statement[]): t.TSModuleBlock;
+  tsParameterProperty(parameter: t.BindingIdentifier | t.AssignmentPattern, opts?: {
+    accessibility?: t.TSAccessibility | null;
+    readonly?: boolean;
+    override?: boolean;
+    decorators?: t.Decorator[];
+  }): t.TSParameterProperty;
+  tsAsExpression(expression: t.Expression, typeAnnotation: t.TSType): t.TSAsExpression;
+  tsSatisfiesExpression(expression: t.Expression, typeAnnotation: t.TSType): t.TSSatisfiesExpression;
+  tsTypeAssertion(typeAnnotation: t.TSType, expression: t.Expression): t.TSTypeAssertion;
+  tsNonNullExpression(expression: t.Expression): t.TSNonNullExpression;
+  tsInstantiationExpression(expression: t.Expression, typeArguments: t.TSTypeParameterInstantiation): t.TSInstantiationExpression;
+  tsExportAssignment(expression: t.Expression): t.TSExportAssignment;
+  tsNamespaceExportDeclaration(id: t.IdentifierName): t.TSNamespaceExportDeclaration;
+  tsImportEqualsDeclaration(id: t.BindingIdentifier, moduleReference: t.TSModuleReference, importKind?: t.ImportOrExportKind): t.TSImportEqualsDeclaration;
+  tsExternalModuleReference(expression: t.StringLiteral): t.TSExternalModuleReference;
+  tsDeclareFunction(id: t.BindingIdentifier | null, params: t.FunctionParameter[], opts?: {
+    async?: boolean;
+    generator?: boolean;
+    returnType?: t.TSTypeAnnotation | null;
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+    declare?: boolean;
+  }): t.TSDeclareFunction;
+  tsEmptyBodyFunctionExpression(params: t.FunctionParameter[], opts?: {
+    id?: t.BindingIdentifier | null;
+    returnType?: t.TSTypeAnnotation | null;
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+  }): t.TSEmptyBodyFunctionExpression;
+  hashbang(value: string): t.Hashbang;
+  program(body?: Array<t.Statement | t.ModuleDeclaration | t.Directive>, opts?: {
+    sourceType?: t.ModuleKind;
+    hashbang?: t.Hashbang | null;
+  }): t.Program;
+};
+//#endregion
+//#region src/walk/sync.d.ts
+/**
+ * Walk an AST depth first, dispatching to typed visitors and mutating in place.
+ *
+ * @param root     The node to start from, usually a `Program`.
+ * @param visitors Handlers keyed by node `type`, alias group, or `enter`/`leave`.
+ * @param state    Optional value exposed as `path.state` throughout the walk.
+ * @returns The root node, or its replacement if the root was replaced.
+ *
+ * @example
+ * ```ts
+ * walk(program, {
+ *   Identifier(node) {
+ *     console.log(node.name);
+ *   },
+ *   CallExpression(node, path) {
+ *     if (node.callee.type === "MemberExpression") path.skip();
+ *   },
+ * });
+ * ```
+ */
+declare function walk<T extends Node, S = unknown>(root: T, visitors: Visitors<S>, state?: S): T;
+//#endregion
+//#region src/walk/async.d.ts
+/**
+ * Like {@link walk}, but visitors may be `async`. Handlers are awaited one at a
+ * time in depth-first order, so mutation behaves exactly as in the sync walk.
+ * Reach for this only when a visitor needs to await I/O; prefer {@link walk}
+ * otherwise, as awaiting has per-node overhead.
+ *
+ * @returns A promise of the root node, or its replacement if the root was replaced.
+ */
+declare function walkAsync<T extends Node, S = unknown>(root: T, visitors: AsyncVisitors<S>, state?: S): Promise<T>;
+//#endregion
+export { type AliasMap, type AliasName, type AsyncVisitFn, type AsyncVisitor, type AsyncVisitors, type ChildKeys, type NodeOfType, type NodeType, type Path, type VisitFn, type Visitor, type Visitors, b, is, walk, walkAsync };