using @moonrockz/krueger/parser { type AttributeGroup }

using @moonrockz/krueger/dialect { type AttributeSyntax }

using @moonrockz/krueger/parser { type AttributeTarget }

using @moonrockz/krueger/scanner { type Block }

using @moonrockz/krueger/ast { type Case }

using @moonrockz/krueger/ast { type CaseBlock }

type Cases = ArrayView[
@moonrockz/krueger/ast.Case
Case]

using @moonrockz/krueger/scanner { type Chunk }

using @moonrockz/krueger/scanner { type Color }

using @moonrockz/krueger/scanner { type Comment }

using @moonrockz/krueger/scanner { type CommentKind }

using @moonrockz/krueger/syntax { type Control }

using @moonrockz/krueger/ast { type Declaration }

using @moonrockz/krueger/cst { type DeclarationCst }

using @moonrockz/krueger/ast { type DecodeError }

using @moonrockz/krueger/ast { type DefaultModuleData }

using @moonrockz/krueger/scanner { type Diagnostic }

using @moonrockz/krueger/dialect { type Dialect }

using @moonrockz/krueger/parser { type DocAttribute }

type Documentation = String

using @moonrockz/krueger/ast { type EffectModuleData }

using @moonrockz/krueger/syntax { type EnterEvent }

using @moonrockz/krueger/syntax { type Event }

using @moonrockz/krueger/syntax { type EventReader }

using @moonrockz/krueger/syntax { trait EventSource }

using @moonrockz/krueger/ast { type ExposedType }

using @moonrockz/krueger/ast { type Exposing }

using @moonrockz/krueger/ast { type Expression }

using @moonrockz/krueger/ast { type File }

using @moonrockz/krueger/ast { type Function }

using @moonrockz/krueger/cst { type FunctionCst }

using @moonrockz/krueger/ast { type FunctionImplementation }

using @moonrockz/krueger/syntax { trait Handler }

using @moonrockz/krueger/ast { type Import }

using @moonrockz/krueger/cst { type ImportCst }

using @moonrockz/krueger/ast { type Infix }

using @moonrockz/krueger/ast { type InfixDirection }

using @moonrockz/krueger/scanner { type KeywordKind }

using @moonrockz/krueger/ast { type Lambda }

using @moonrockz/krueger/syntax { type LeaveEvent }

using @moonrockz/krueger/ast { type LetBlock }

using @moonrockz/krueger/ast { type LetDeclaration }

using @moonrockz/krueger/ast { type Location }

using @moonrockz/krueger/ast { type Module }

using @moonrockz/krueger/cst { type ModuleCst }

using @moonrockz/krueger/cst { type ModuleHeaderCst }

type ModuleName = ArrayView[String]

using @moonrockz/krueger/ast { type Node }

using @moonrockz/krueger/syntax { type NodePath }

using @moonrockz/krueger/syntax { type NodeRef }

using @moonrockz/krueger/dialect { type OperatorDef }

using @moonrockz/krueger/parser { type ParseResult }

using @moonrockz/krueger/syntax { type PathStep }

using @moonrockz/krueger/ast { type Pattern }

using @moonrockz/krueger/scanner { type Position }

using @moonrockz/krueger/ast { type QualifiedNameRef }

using @moonrockz/krueger/ast { type Range }

type RecordDefinition = ArrayView[
@moonrockz/krueger/ast.Node
Node[
@moonrockz/krueger/ast.RecordField
RecordField]]

using @moonrockz/krueger/ast { type RecordField }

using @moonrockz/krueger/ast { type RecordSetter }

using @moonrockz/krueger/dialect { type Rule }

using @moonrockz/krueger/scanner { type ScanErrorList }

using @moonrockz/krueger/scanner { trait Scanner }

using @moonrockz/krueger/scanner { type Severity }

using @moonrockz/krueger/ast { type Signature }

using @moonrockz/krueger/scanner { type SourceText }

using @moonrockz/krueger/scanner { type Span }

using @moonrockz/krueger/scanner { type Token }

using @moonrockz/krueger/scanner { type TokenKind }

using @moonrockz/krueger/scanner { type TokenStream }

using @moonrockz/krueger/ast { type TopLevelExpose }

using @moonrockz/krueger/syntax { type Tree }

using @moonrockz/krueger/syntax { type TreeCursor }

using @moonrockz/krueger/scanner { type Trivia }

using @moonrockz/krueger/ast { type Type }

using @moonrockz/krueger/ast { type TypeAlias }

using @moonrockz/krueger/cst { type TypeAliasCst }

using @moonrockz/krueger/ast { type TypeAnnotation }

using @moonrockz/krueger/cst { type UnionTypeCst }

using @moonrockz/krueger/ast { type ValueConstructor }

using @moonrockz/krueger/syntax { trait Visitor }

fn[V : 
@moonrockz/krueger/syntax.Visitor
Visitor] accept(root : 
@moonrockz/krueger/syntax.NodeRef
NodeRef, visitor : V) -> Unit

fn diagnostic_description(code : String) -> String?

fn encode_attributes(groups : Array[
@moonrockz/krueger/parser.AttributeGroup
AttributeGroup]) -> Json

fn encode_attributes_with(groups : Array[
@moonrockz/krueger/parser.AttributeGroup
AttributeGroup], exact_ints~ : Bool) -> Json

fn encode_diagnostics(diags : Array[
@moonrockz/krueger/scanner.Diagnostic
Diagnostic]) -> Json

fn[A] fold(root : 
@moonrockz/krueger/syntax.NodeRef
NodeRef, init : A, enter : (A, 
@moonrockz/krueger/syntax.NodeRef
NodeRef) -> (A, 
@moonrockz/krueger/syntax.Control
Control), leave? : (A, 
@moonrockz/krueger/syntax.NodeRef
NodeRef) -> A) -> A

fn is_lower_start(c : Char) -> Bool

fn is_name_part(c : Char) -> Bool

fn is_upper_start(c : Char) -> Bool

fn kind_table() -> Array[(String, String, Array[String])]

fn parse_module(source : 
@moonrockz/krueger/scanner.SourceText
SourceText, dialect? : 
@moonrockz/krueger/dialect.Dialect
Dialect) -> 
@moonrockz/krueger/parser.ParseResult
ParseResult

fn parse_tokens(tokens : 
@moonrockz/krueger/scanner.TokenStream
TokenStream, dialect? : 
@moonrockz/krueger/dialect.Dialect
Dialect) -> 
@moonrockz/krueger/parser.ParseResult
ParseResult

fn[S : 
@moonrockz/krueger/syntax.EventSource
EventSource, H : 
@moonrockz/krueger/syntax.Handler
Handler] push_events(source : S, handler : H) -> Unit

fn render_elm_json(diags : Array[
@moonrockz/krueger/scanner.Diagnostic
Diagnostic], source : 
@moonrockz/krueger/scanner.SourceText
SourceText, path : String) -> Json

fn render_plain(diag : 
@moonrockz/krueger/scanner.Diagnostic
Diagnostic, source : 
@moonrockz/krueger/scanner.SourceText
SourceText, path : String) -> String

fn render_terminal(diag : 
@moonrockz/krueger/scanner.Diagnostic
Diagnostic, source : 
@moonrockz/krueger/scanner.SourceText
SourceText, path : String) -> String

fn standard_operators() -> Array[
@moonrockz/krueger/dialect.OperatorDef
OperatorDef]

fn tokenize(source : 
@moonrockz/krueger/scanner.SourceText
SourceText, dialect? : 
@moonrockz/krueger/dialect.Dialect
Dialect) -> Result[
@moonrockz/krueger/scanner.TokenStream
TokenStream, 
@moonrockz/krueger/scanner.ScanErrorList
ScanErrorList]

fn version() -> String

fn walk(root : 
@moonrockz/krueger/syntax.NodeRef
NodeRef, enter : (
@moonrockz/krueger/syntax.NodeRef
NodeRef) -> 
@moonrockz/krueger/syntax.Control
Control, leave? : (
@moonrockz/krueger/syntax.NodeRef
NodeRef) -> Unit) -> Unit