@spyglassmc/mcdoc 0.3.3 → 0.3.5

package/lib/node/index.d.ts

@@ -4,134 +4,134 @@ export interface ModuleNode extends AstNode {
     type: 'mcdoc:module';
     children: TopLevelNode[];
 }
-export declare const ModuleNode: Readonly<{
-    is(node: AstNode | undefined): node is ModuleNode;
-}>;
+export declare namespace ModuleNode {
+    function is(node: AstNode | undefined): node is ModuleNode;
+}
 export type TopLevelNode = CommentNode | DispatchStatementNode | EnumNode | InjectionNode | StructNode | TypeAliasNode | UseStatementNode;
-export declare const TopLevelNode: Readonly<{
-    is(node: AstNode | undefined): node is TopLevelNode;
-}>;
+export declare namespace TopLevelNode {
+    function is(node: AstNode | undefined): node is TopLevelNode;
+}
 export interface DispatchStatementNode extends AstNode {
     type: 'mcdoc:dispatch_statement';
-    children: (CommentNode | AttributeNode | LiteralNode | ResourceLocationNode | IndexBodyNode | TypeParamBlockNode | TypeNode)[];
+    children: (CommentNode | PrelimNode | LiteralNode | ResourceLocationNode | IndexBodyNode | TypeParamBlockNode | TypeNode)[];
 }
-export declare const DispatchStatementNode: Readonly<{
-    destruct(node: DispatchStatementNode): {
+export declare namespace DispatchStatementNode {
+    function destruct(node: DispatchStatementNode): {
         attributes: AttributeNode[];
         location?: ResourceLocationNode;
         index?: IndexBodyNode;
         target?: TypeNode;
         typeParams?: TypeParamBlockNode;
     };
-    is(node: AstNode | undefined): node is DispatchStatementNode;
-}>;
+    function is(node: AstNode | undefined): node is DispatchStatementNode;
+}
 export interface LiteralNode extends AstNode {
     type: 'mcdoc:literal';
     value: string;
     colorTokenType?: ColorTokenType;
 }
-export declare const LiteralNode: Readonly<{
-    is(node: AstNode | undefined): node is LiteralNode;
-}>;
+export declare namespace LiteralNode {
+    function is(node: AstNode | undefined): node is LiteralNode;
+}
 export interface IndexBodyNode extends AstNode {
     type: 'mcdoc:index_body';
     children: (CommentNode | IndexNode)[];
 }
-export declare const IndexBodyNode: Readonly<{
-    destruct(node: IndexBodyNode): {
+export declare namespace IndexBodyNode {
+    function destruct(node: IndexBodyNode): {
         parallelIndices: IndexNode[];
     };
-    is(node: AstNode | undefined): node is IndexBodyNode;
-}>;
+    function is(node: AstNode | undefined): node is IndexBodyNode;
+}
 export type IndexNode = StaticIndexNode | DynamicIndexNode;
-export declare const IndexNode: Readonly<{
-    is(node: AstNode | undefined): node is IndexNode;
-}>;
+export declare namespace IndexNode {
+    function is(node: AstNode | undefined): node is IndexNode;
+}
 export type StaticIndexNode = LiteralNode | IdentifierNode | StringNode | ResourceLocationNode;
-export declare const StaticIndexNode: Readonly<{
-    is(node: AstNode | undefined): node is StaticIndexNode;
-}>;
+export declare namespace StaticIndexNode {
+    function is(node: AstNode | undefined): node is StaticIndexNode;
+}
 export interface IdentifierNode extends SymbolBaseNode {
     type: 'mcdoc:identifier';
 }
-export declare const IdentifierNode: Readonly<{
-    is(node: AstNode | undefined): node is IdentifierNode;
-}>;
+export declare namespace IdentifierNode {
+    function is(node: AstNode | undefined): node is IdentifierNode;
+}
 export interface DynamicIndexNode extends AstNode {
     type: 'mcdoc:dynamic_index';
     children: (CommentNode | AccessorKeyNode)[];
 }
-export declare const DynamicIndexNode: Readonly<{
-    destruct(node: DynamicIndexNode): {
+export declare namespace DynamicIndexNode {
+    function destruct(node: DynamicIndexNode): {
         keys: AccessorKeyNode[];
     };
-    is(node: AstNode | undefined): node is DynamicIndexNode;
-}>;
+    function is(node: AstNode | undefined): node is DynamicIndexNode;
+}
 export type AccessorKeyNode = LiteralNode | IdentifierNode | StringNode;
-export declare const AccessorKeyNode: Readonly<{
-    is(node: AstNode | undefined): node is AccessorKeyNode;
-}>;
+export declare namespace AccessorKeyNode {
+    function is(node: AstNode | undefined): node is AccessorKeyNode;
+}
 export type TypeNode = AnyTypeNode | BooleanTypeNode | StringTypeNode | LiteralTypeNode | NumericTypeNode | PrimitiveArrayTypeNode | ListTypeNode | TupleTypeNode | EnumNode | StructNode | ReferenceTypeNode | DispatcherTypeNode | UnionTypeNode;
-export declare const TypeNode: Readonly<{
-    is(node: AstNode | undefined): node is TypeNode;
-}>;
+export declare namespace TypeNode {
+    function is(node: AstNode | undefined): node is TypeNode;
+}
 export interface TypeBaseNode<CN extends AstNode> extends AstNode {
     type: `mcdoc:${string}`;
     children: (CommentNode | AttributeNode | IndexBodyNode | TypeArgBlockNode | CN)[];
 }
-export declare const TypeBaseNode: Readonly<{
-    destruct(node: TypeBaseNode<any>): {
+export declare namespace TypeBaseNode {
+    function destruct(node: TypeBaseNode<any>): {
         appendixes: (IndexBodyNode | TypeArgBlockNode)[];
         attributes: AttributeNode[];
     };
-}>;
+}
 export interface AttributeNode extends AstNode {
     type: 'mcdoc:attribute';
     children: (CommentNode | IdentifierNode | AttributeValueNode)[];
 }
-export declare const AttributeNode: Readonly<{
-    destruct(node: AttributeNode): {
+export declare namespace AttributeNode {
+    function destruct(node: AttributeNode): {
         name: IdentifierNode;
         value: AttributeValueNode | undefined;
     };
-    is(node: AstNode | undefined): node is AttributeNode;
-}>;
+    function is(node: AstNode | undefined): node is AttributeNode;
+}
 export type AttributeValueNode = TypeNode | AttributeTreeNode;
-export declare const AttributeValueNode: Readonly<{
-    is(node: AstNode | undefined): node is AttributeValueNode;
-}>;
+export declare namespace AttributeValueNode {
+    function is(node: AstNode | undefined): node is AttributeValueNode;
+}
 export interface AttributeTreeNode extends AstNode {
     type: 'mcdoc:attribute/tree';
     children: (CommentNode | AttributeTreePosValuesNode | AttributeTreeNamedValuesNode)[];
     delim: '(' | '[' | '{';
 }
-export declare const AttributeTreeNode: Readonly<{
-    destruct(node: AttributeTreeNode): {
+export declare namespace AttributeTreeNode {
+    function destruct(node: AttributeTreeNode): {
         positional?: AttributeTreePosValuesNode;
         named?: AttributeTreeNamedValuesNode;
     };
-    is(node: AstNode | undefined): node is AttributeTreeNode;
-}>;
+    function is(node: AstNode | undefined): node is AttributeTreeNode;
+}
 export interface AttributeTreePosValuesNode extends AstNode {
     type: 'mcdoc:attribute/tree/pos';
     children: (CommentNode | AttributeValueNode)[];
 }
-export declare const AttributeTreePosValuesNode: Readonly<{
-    destruct(node: AttributeTreePosValuesNode): {
+export declare namespace AttributeTreePosValuesNode {
+    function destruct(node: AttributeTreePosValuesNode): {
         values: AttributeValueNode[];
     };
-    is(node: AstNode | undefined): node is AttributeTreePosValuesNode;
-}>;
+    function is(node: AstNode | undefined): node is AttributeTreePosValuesNode;
+}
 export interface AttributeTreeNamedValuesNode extends AstNode {
     type: 'mcdoc:attribute/tree/named';
     children: (CommentNode | IdentifierNode | StringNode | AttributeValueNode)[];
 }
-export declare const AttributeTreeNamedValuesNode: Readonly<{
-    destruct(node: AttributeTreeNamedValuesNode): {
+export declare namespace AttributeTreeNamedValuesNode {
+    function destruct(node: AttributeTreeNamedValuesNode): {
         values: AttributeTreeNamedKeyValuePair[];
     };
-    is(node: AstNode | undefined): node is AttributeTreeNamedValuesNode;
-}>;
+    function is(node: AstNode | undefined): node is AttributeTreeNamedValuesNode;
+}
 export interface AttributeTreeNamedKeyValuePair {
     key: IdentifierNode | StringNode;
     value: AttributeValueNode;
@@ -140,70 +140,70 @@ export interface TypeArgBlockNode extends AstNode {
     type: 'mcdoc:type_arg_block';
     children: (CommentNode | TypeNode)[];
 }
-export declare const TypeArgBlockNode: Readonly<{
-    destruct(node: TypeArgBlockNode): {
+export declare namespace TypeArgBlockNode {
+    function destruct(node: TypeArgBlockNode): {
         args: TypeNode[];
     };
-    is(node: AstNode | undefined): node is TypeArgBlockNode;
-}>;
+    function is(node: AstNode | undefined): node is TypeArgBlockNode;
+}
 export interface AnyTypeNode extends TypeBaseNode<LiteralNode> {
     type: 'mcdoc:type/any';
 }
-export declare const AnyTypeNode: Readonly<{
-    is(node: AstNode | undefined): node is AnyTypeNode;
-}>;
+export declare namespace AnyTypeNode {
+    function is(node: AstNode | undefined): node is AnyTypeNode;
+}
 export interface BooleanTypeNode extends TypeBaseNode<LiteralNode> {
     type: 'mcdoc:type/boolean';
 }
-export declare const BooleanTypeNode: Readonly<{
-    is(node: AstNode | undefined): node is BooleanTypeNode;
-}>;
+export declare namespace BooleanTypeNode {
+    function is(node: AstNode | undefined): node is BooleanTypeNode;
+}
 export interface IntRangeNode extends AstNode {
     type: 'mcdoc:int_range';
     children: (IntegerNode | LiteralNode)[];
 }
-export declare const IntRangeNode: Readonly<{
-    destruct(node: IntRangeNode): {
+export declare namespace IntRangeNode {
+    function destruct(node: IntRangeNode): {
         kind: RangeKind;
         min?: IntegerNode;
         max?: IntegerNode;
     };
-    is(node: AstNode | undefined): node is IntRangeNode;
-}>;
+    function is(node: AstNode | undefined): node is IntRangeNode;
+}
 export interface LiteralTypeNode extends TypeBaseNode<LiteralTypeValueNode> {
     type: 'mcdoc:type/literal';
 }
-export declare const LiteralTypeNode: Readonly<{
-    destruct(node: LiteralTypeNode): {
+export declare namespace LiteralTypeNode {
+    function destruct(node: LiteralTypeNode): {
         value: LiteralTypeValueNode;
     };
-    is(node: AstNode | undefined): node is LiteralTypeNode;
-}>;
+    function is(node: AstNode | undefined): node is LiteralTypeNode;
+}
 export type LiteralTypeValueNode = LiteralNode | TypedNumberNode | StringNode;
-export declare const LiteralTypeValueNode: Readonly<{
-    is(node: AstNode | undefined): node is LiteralTypeValueNode;
-}>;
+export declare namespace LiteralTypeValueNode {
+    function is(node: AstNode | undefined): node is LiteralTypeValueNode;
+}
 export interface TypedNumberNode extends AstNode {
     type: 'mcdoc:typed_number';
     children: (FloatNode | LiteralNode)[];
 }
-export declare const TypedNumberNode: Readonly<{
-    destruct(node: TypedNumberNode): {
+export declare namespace TypedNumberNode {
+    function destruct(node: TypedNumberNode): {
         value: FloatNode;
         suffix?: LiteralNode;
     };
-    is(node: AstNode | undefined): node is TypedNumberNode;
-}>;
+    function is(node: AstNode | undefined): node is TypedNumberNode;
+}
 export interface NumericTypeNode extends TypeBaseNode<LiteralNode | FloatRangeNode | IntRangeNode> {
     type: 'mcdoc:type/numeric_type';
 }
-export declare const NumericTypeNode: Readonly<{
-    destruct(node: NumericTypeNode): {
+export declare namespace NumericTypeNode {
+    function destruct(node: NumericTypeNode): {
         numericKind: LiteralNode;
         valueRange?: FloatRangeNode | IntRangeNode;
     };
-    is(node: AstNode | undefined): node is NumericTypeNode;
-}>;
+    function is(node: AstNode | undefined): node is NumericTypeNode;
+}
 export declare const RangeExclusiveChar = "<";
 /**
  * A 2-bit binary number is used to represent the kind of range.
@@ -216,270 +216,269 @@ export interface FloatRangeNode extends AstNode {
     type: 'mcdoc:float_range';
     children: (FloatNode | LiteralNode)[];
 }
-export declare const FloatRangeNode: Readonly<{
-    destruct(node: FloatRangeNode): {
+export declare namespace FloatRangeNode {
+    function destruct(node: FloatRangeNode): {
         kind: RangeKind;
         min?: FloatNode;
         max?: FloatNode;
     };
-    is(node: AstNode | undefined): node is FloatRangeNode;
-}>;
+    function is(node: AstNode | undefined): node is FloatRangeNode;
+}
 export interface PrimitiveArrayTypeNode extends TypeBaseNode<LiteralNode | IntRangeNode> {
     type: 'mcdoc:type/primitive_array';
 }
-export declare const PrimitiveArrayTypeNode: Readonly<{
-    destruct(node: PrimitiveArrayTypeNode): {
+export declare namespace PrimitiveArrayTypeNode {
+    function destruct(node: PrimitiveArrayTypeNode): {
         arrayKind: LiteralNode;
-        lengthRange?: IntRangeNode | undefined;
-        valueRange?: IntRangeNode | undefined;
+        lengthRange?: IntRangeNode;
+        valueRange?: IntRangeNode;
     };
-    is(node: AstNode | undefined): node is PrimitiveArrayTypeNode;
-}>;
+    function is(node: AstNode | undefined): node is PrimitiveArrayTypeNode;
+}
 export interface ListTypeNode extends TypeBaseNode<TypeNode | IntRangeNode> {
     type: 'mcdoc:type/list';
 }
-export declare const ListTypeNode: Readonly<{
-    destruct(node: ListTypeNode): {
+export declare namespace ListTypeNode {
+    function destruct(node: ListTypeNode): {
         item: TypeNode;
         lengthRange?: IntRangeNode;
     };
-    is(node: AstNode | undefined): node is ListTypeNode;
-}>;
+    function is(node: AstNode | undefined): node is ListTypeNode;
+}
 export interface StringTypeNode extends TypeBaseNode<LiteralNode | IntRangeNode> {
     type: 'mcdoc:type/string';
 }
-export declare const StringTypeNode: Readonly<{
-    destruct(node: StringTypeNode): {
+export declare namespace StringTypeNode {
+    function destruct(node: StringTypeNode): {
         lengthRange?: IntRangeNode;
     };
-    is(node: AstNode | undefined): node is StringTypeNode;
-}>;
+    function is(node: AstNode | undefined): node is StringTypeNode;
+}
 export interface TupleTypeNode extends TypeBaseNode<TypeNode> {
     type: 'mcdoc:type/tuple';
 }
-export declare const TupleTypeNode: Readonly<{
-    destruct(node: TupleTypeNode): {
+export declare namespace TupleTypeNode {
+    function destruct(node: TupleTypeNode): {
         items: TypeNode[];
     };
-    is(node: AstNode | undefined): node is TupleTypeNode;
-}>;
+    function is(node: AstNode | undefined): node is TupleTypeNode;
+}
 export interface EnumNode extends TypeBaseNode<DocCommentsNode | LiteralNode | IdentifierNode | EnumBlockNode> {
     type: 'mcdoc:enum';
 }
-declare const EnumKinds: Set<"string" | "float" | "byte" | "short" | "int" | "long" | "double">;
-export type EnumKind = typeof EnumKinds extends Set<infer V> ? V : never;
-export declare const EnumNode: Readonly<{
-    kinds: Set<"string" | "float" | "byte" | "short" | "int" | "long" | "double">;
-    destruct(node: EnumNode): {
+export type EnumKind = typeof EnumNode.Kinds extends Set<infer V> ? V : never;
+export declare namespace EnumNode {
+    const Kinds: Set<"string" | "float" | "byte" | "short" | "int" | "long" | "double">;
+    function destruct(node: EnumNode): {
         block: EnumBlockNode;
         docComments?: DocCommentsNode;
         enumKind?: EnumKind;
         identifier?: IdentifierNode;
         keyword: LiteralNode;
     };
-    is(node: AstNode | undefined): node is EnumNode;
-}>;
+    function is(node: AstNode | undefined): node is EnumNode;
+}
 export interface DocCommentsNode extends AstNode {
     type: 'mcdoc:doc_comments';
     children: CommentNode[];
 }
-export declare const DocCommentsNode: Readonly<{
+export declare namespace DocCommentsNode {
     /**
      * @returns The text content of this doc comment block.
      */
-    asText(node: DocCommentsNode | undefined): string | undefined;
-    is(node: AstNode | undefined): node is DocCommentsNode;
-}>;
+    function asText(node: DocCommentsNode | undefined): string | undefined;
+    function is(node: AstNode | undefined): node is DocCommentsNode;
+}
 export interface EnumBlockNode extends AstNode {
     type: 'mcdoc:enum/block';
     children: (CommentNode | EnumFieldNode)[];
 }
-export declare const EnumBlockNode: Readonly<{
-    destruct(node: EnumBlockNode): {
+export declare namespace EnumBlockNode {
+    function destruct(node: EnumBlockNode): {
         fields: EnumFieldNode[];
     };
-    is(node: AstNode | undefined): node is EnumBlockNode;
-}>;
+    function is(node: AstNode | undefined): node is EnumBlockNode;
+}
 export interface EnumFieldNode extends AstNode {
     type: 'mcdoc:enum/field';
     children: (CommentNode | PrelimNode | IdentifierNode | EnumValueNode)[];
 }
-export declare const EnumFieldNode: Readonly<{
-    destruct(node: EnumFieldNode): {
+export declare namespace EnumFieldNode {
+    function destruct(node: EnumFieldNode): {
         attributes: AttributeNode[];
         identifier: IdentifierNode;
         value: EnumValueNode;
     };
-    is(node: AstNode | undefined): node is EnumFieldNode;
-}>;
+    function is(node: AstNode | undefined): node is EnumFieldNode;
+}
 export type EnumValueNode = TypedNumberNode | StringNode;
-export declare const EnumValueNode: Readonly<{
-    is(node: AstNode | undefined): node is EnumValueNode;
-}>;
+export declare namespace EnumValueNode {
+    function is(node: AstNode | undefined): node is EnumValueNode;
+}
 export type PrelimNode = AttributeNode | DocCommentsNode;
-export declare const PrelimNode: Readonly<{
-    is(node: AstNode | undefined): node is PrelimNode;
-}>;
+export declare namespace PrelimNode {
+    function is(node: AstNode | undefined): node is PrelimNode;
+}
 export interface StructNode extends TypeBaseNode<DocCommentsNode | LiteralNode | IdentifierNode | StructBlockNode> {
     type: 'mcdoc:struct';
 }
-export declare const StructNode: Readonly<{
-    destruct(node: StructNode): {
+export declare namespace StructNode {
+    function destruct(node: StructNode): {
         block: StructBlockNode;
         docComments?: DocCommentsNode;
         identifier?: IdentifierNode;
         keyword: LiteralNode;
     };
-    is(node: AstNode | undefined): node is StructNode;
-}>;
+    function is(node: AstNode | undefined): node is StructNode;
+}
 export interface ReferenceTypeNode extends TypeBaseNode<PathNode> {
     type: 'mcdoc:type/reference';
 }
-export declare const ReferenceTypeNode: Readonly<{
-    destruct(node: ReferenceTypeNode): {
+export declare namespace ReferenceTypeNode {
+    function destruct(node: ReferenceTypeNode): {
         path: PathNode;
     };
-    is(node: AstNode | undefined): node is ReferenceTypeNode;
-}>;
+    function is(node: AstNode | undefined): node is ReferenceTypeNode;
+}
 export interface TypeParamBlockNode extends AstNode {
     type: 'mcdoc:type_param_block';
     children: (CommentNode | TypeParamNode)[];
 }
-export declare const TypeParamBlockNode: Readonly<{
-    destruct(node: TypeParamBlockNode): {
+export declare namespace TypeParamBlockNode {
+    function destruct(node: TypeParamBlockNode): {
         params: TypeParamNode[];
     };
-    is(node: AstNode | undefined): node is TypeParamBlockNode;
-}>;
+    function is(node: AstNode | undefined): node is TypeParamBlockNode;
+}
 export interface TypeParamNode extends AstNode {
     type: 'mcdoc:type_param';
     children: (CommentNode | IdentifierNode | LiteralNode)[];
 }
-export declare const TypeParamNode: Readonly<{
-    destruct(node: TypeParamNode): {
+export declare namespace TypeParamNode {
+    function destruct(node: TypeParamNode): {
         identifier: IdentifierNode;
     };
-    is(node: AstNode | undefined): node is TypeParamNode;
-}>;
+    function is(node: AstNode | undefined): node is TypeParamNode;
+}
 export interface PathNode extends AstNode {
     type: 'mcdoc:path';
     children: (LiteralNode | IdentifierNode)[];
     isAbsolute?: boolean;
 }
-export declare const PathNode: Readonly<{
-    destruct(node: PathNode | undefined): {
+export declare namespace PathNode {
+    function destruct(node: PathNode | undefined): {
         children: (LiteralNode | IdentifierNode)[];
         isAbsolute?: boolean;
         lastIdentifier?: IdentifierNode;
     };
-    is(node: AstNode | undefined): node is PathNode;
-}>;
+    function is(node: AstNode | undefined): node is PathNode;
+}
 export interface StructBlockNode extends AstNode {
     type: 'mcdoc:struct/block';
     children: (CommentNode | StructFieldNode)[];
 }
-export declare const StructBlockNode: Readonly<{
-    destruct(node: StructBlockNode): {
+export declare namespace StructBlockNode {
+    function destruct(node: StructBlockNode): {
         fields: StructFieldNode[];
     };
-    is(node: AstNode | undefined): node is StructBlockNode;
-}>;
+    function is(node: AstNode | undefined): node is StructBlockNode;
+}
 export type StructFieldNode = StructPairFieldNode | StructSpreadFieldNode;
-export declare const StructFieldNode: Readonly<{
-    is(node: AstNode | undefined): node is StructFieldNode;
-}>;
+export declare namespace StructFieldNode {
+    function is(node: AstNode | undefined): node is StructFieldNode;
+}
 export interface StructPairFieldNode extends AstNode {
     type: 'mcdoc:struct/field/pair';
     children: (CommentNode | PrelimNode | StructKeyNode | TypeNode)[];
     isOptional?: boolean;
 }
-export declare const StructPairFieldNode: Readonly<{
-    destruct(node: StructPairFieldNode): {
+export declare namespace StructPairFieldNode {
+    function destruct(node: StructPairFieldNode): {
         attributes: AttributeNode[];
         key: StructKeyNode;
         type: TypeNode;
         isOptional?: boolean;
     };
-    is(node: AstNode | undefined): node is StructPairFieldNode;
-}>;
+    function is(node: AstNode | undefined): node is StructPairFieldNode;
+}
 export type StructKeyNode = StringNode | IdentifierNode | StructMapKeyNode;
-export declare const StructKeyNode: Readonly<{
-    is(node: AstNode | undefined): node is StructKeyNode;
-}>;
+export declare namespace StructKeyNode {
+    function is(node: AstNode | undefined): node is StructKeyNode;
+}
 export interface StructMapKeyNode extends AstNode {
     type: 'mcdoc:struct/map_key';
     children: (CommentNode | TypeNode)[];
 }
-export declare const StructMapKeyNode: Readonly<{
-    destruct(node: StructMapKeyNode): {
+export declare namespace StructMapKeyNode {
+    function destruct(node: StructMapKeyNode): {
         type: TypeNode;
     };
-    is(node: AstNode | undefined): node is StructMapKeyNode;
-}>;
+    function is(node: AstNode | undefined): node is StructMapKeyNode;
+}
 export interface StructSpreadFieldNode extends AstNode {
     type: 'mcdoc:struct/field/spread';
     children: (CommentNode | AttributeNode | TypeNode)[];
 }
-export declare const StructSpreadFieldNode: Readonly<{
-    destruct(node: StructSpreadFieldNode): {
+export declare namespace StructSpreadFieldNode {
+    function destruct(node: StructSpreadFieldNode): {
         attributes: AttributeNode[];
         type: TypeNode;
     };
-    is(node: AstNode | undefined): node is StructSpreadFieldNode;
-}>;
+    function is(node: AstNode | undefined): node is StructSpreadFieldNode;
+}
 export interface DispatcherTypeNode extends TypeBaseNode<ResourceLocationNode | IndexBodyNode> {
     type: 'mcdoc:type/dispatcher';
 }
-export declare const DispatcherTypeNode: Readonly<{
-    destruct(node: DispatcherTypeNode): {
+export declare namespace DispatcherTypeNode {
+    function destruct(node: DispatcherTypeNode): {
         location: ResourceLocationNode;
         index: IndexBodyNode;
     };
-    is(node: AstNode | undefined): node is DispatcherTypeNode;
-}>;
+    function is(node: AstNode | undefined): node is DispatcherTypeNode;
+}
 export interface UnionTypeNode extends TypeBaseNode<TypeNode> {
     type: 'mcdoc:type/union';
 }
-export declare const UnionTypeNode: Readonly<{
-    destruct(node: UnionTypeNode): {
+export declare namespace UnionTypeNode {
+    function destruct(node: UnionTypeNode): {
         members: TypeNode[];
     };
-    is(node: AstNode | undefined): node is UnionTypeNode;
-}>;
+    function is(node: AstNode | undefined): node is UnionTypeNode;
+}
 export interface InjectionNode extends AstNode {
     type: 'mcdoc:injection';
     children: (CommentNode | LiteralNode | InjectionContentNode)[];
 }
-export declare const InjectionNode: Readonly<{
-    destruct(node: InjectionNode): {
+export declare namespace InjectionNode {
+    function destruct(node: InjectionNode): {
         injection: InjectionContentNode;
     };
-    is(node: AstNode | undefined): node is InjectionNode;
-}>;
+    function is(node: AstNode | undefined): node is InjectionNode;
+}
 export type InjectionContentNode = EnumInjectionNode | StructInjectionNode;
-export declare const InjectionContentNode: Readonly<{
-    is(node: AstNode | undefined): node is InjectionContentNode;
-}>;
+export declare namespace InjectionContentNode {
+    function is(node: AstNode | undefined): node is InjectionContentNode;
+}
 export interface EnumInjectionNode extends AstNode {
     type: 'mcdoc:injection/enum';
     children: (CommentNode | LiteralNode | PathNode | EnumBlockNode)[];
 }
-export declare const EnumInjectionNode: Readonly<{
-    is(node: AstNode | undefined): node is EnumInjectionNode;
-}>;
+export declare namespace EnumInjectionNode {
+    function is(node: AstNode | undefined): node is EnumInjectionNode;
+}
 export interface StructInjectionNode extends AstNode {
     type: 'mcdoc:injection/struct';
     children: (CommentNode | LiteralNode | PathNode | StructBlockNode)[];
 }
-export declare const StructInjectionNode: Readonly<{
-    is(node: AstNode | undefined): node is StructInjectionNode;
-}>;
+export declare namespace StructInjectionNode {
+    function is(node: AstNode | undefined): node is StructInjectionNode;
+}
 export interface TypeAliasNode extends AstNode {
     type: 'mcdoc:type_alias';
     children: (CommentNode | PrelimNode | LiteralNode | IdentifierNode | TypeParamBlockNode | TypeNode)[];
 }
-export declare const TypeAliasNode: Readonly<{
-    destruct(node: TypeAliasNode): {
+export declare namespace TypeAliasNode {
+    function destruct(node: TypeAliasNode): {
         attributes: AttributeNode[];
         docComments?: DocCommentsNode;
         identifier: IdentifierNode;
@@ -487,18 +486,17 @@ export declare const TypeAliasNode: Readonly<{
         typeParams?: TypeParamBlockNode;
         rhs?: TypeNode;
     };
-    is(node: AstNode | undefined): node is TypeAliasNode;
-}>;
+    function is(node: AstNode | undefined): node is TypeAliasNode;
+}
 export interface UseStatementNode extends AstNode {
     type: 'mcdoc:use_statement';
     children: (CommentNode | LiteralNode | PathNode | IdentifierNode)[];
 }
-export declare const UseStatementNode: Readonly<{
-    destruct(node: UseStatementNode): {
+export declare namespace UseStatementNode {
+    function destruct(node: UseStatementNode): {
         binding?: IdentifierNode;
         path?: PathNode;
     };
-    is(node: AstNode | undefined): node is UseStatementNode;
-}>;
-export {};
+    function is(node: AstNode | undefined): node is UseStatementNode;
+}
 //# sourceMappingURL=index.d.ts.map