@mohsen-azimi/tsz-dev 0.1.1

package/bundler/tsz_wasm.d.ts

@@ -0,0 +1,2104 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Comparison result for ordering operations.
+ * Matches TypeScript's `Comparison` const enum in src/compiler/corePublic.ts
+ */
+export enum Comparison {
+    LessThan = -1,
+    EqualTo = 0,
+    GreaterThan = 1,
+}
+
+/**
+ * `DiagnosticCategory` enum
+ */
+export enum DiagnosticCategory {
+    Warning = 0,
+    Error = 1,
+    Suggestion = 2,
+    Message = 3,
+}
+
+/**
+ * `ModuleKind` enum
+ */
+export enum ModuleKind {
+    None = 0,
+    CommonJS = 1,
+    AMD = 2,
+    UMD = 3,
+    System = 4,
+    ES2015 = 5,
+    ES2020 = 6,
+    ES2022 = 7,
+    ESNext = 99,
+    Node16 = 100,
+    NodeNext = 199,
+    Preserve = 200,
+}
+
+/**
+ * Index into an arena. Used instead of pointers/references for serialization-friendly graphs.
+ */
+export class NodeIndex {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    0: number;
+}
+
+/**
+ * High-performance parser using Node architecture (16 bytes/node).
+ * This is the optimized path for Phase 8 test suite evaluation.
+ */
+export class Parser {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a lib file (e.g., lib.es5.d.ts) for global type resolution.
+     * The lib file will be parsed and bound, and its global symbols will be
+     * available during binding and type checking.
+     */
+    addLibFile(file_name: string, source_text: string): void;
+    /**
+     * Bind the source file and return symbol count.
+     */
+    bindSourceFile(): string;
+    /**
+     * Type check the source file and return diagnostics.
+     */
+    checkSourceFile(): string;
+    /**
+     * Debug interface parsing - dump interface members for diagnostics
+     */
+    debugInterfaceMembers(interface_name: string): string;
+    /**
+     * Debug namespace scoping - dump scope info for all scopes
+     */
+    debugScopes(): string;
+    /**
+     * Debug type lowering - trace what happens when lowering an interface type
+     */
+    debugTypeLowering(interface_name: string): string;
+    /**
+     * Dump all nodes for debugging
+     */
+    dumpAllNodes(start: number, count: number): string;
+    /**
+     * Dump variable declaration info for debugging
+     */
+    dumpVarDecl(var_decl_idx: number): string;
+    /**
+     * Emit the source file as JavaScript (ES5 target, auto-detect CommonJS for modules).
+     */
+    emit(): string;
+    /**
+     * Emit the source file as JavaScript (ES6+ modern output).
+     */
+    emitModern(): string;
+    /**
+     * Emit the source file using pre-computed transforms.
+     */
+    emitWithTransforms(context: WasmTransformContext): string;
+    /**
+     * Generate transform directives based on compiler options.
+     */
+    generateTransforms(target: number, module: number): WasmTransformContext;
+    /**
+     * Get the AST as JSON (for debugging).
+     */
+    getAstJson(): string;
+    /**
+     * Code Actions: Get code actions for a range.
+     */
+    getCodeActions(start_line: number, start_char: number, end_line: number, end_char: number): any;
+    /**
+     * Code Actions: Get code actions for a range with diagnostics context.
+     */
+    getCodeActionsWithContext(start_line: number, start_char: number, end_line: number, end_char: number, context: any): any;
+    /**
+     * Completions: Returns array of `CompletionItem` objects.
+     */
+    getCompletionsAtPosition(line: number, character: number): any;
+    /**
+     * Go to Definition: Returns array of Location objects.
+     */
+    getDefinitionAtPosition(line: number, character: number): any;
+    /**
+     * Get parse diagnostics as JSON.
+     */
+    getDiagnosticsJson(): string;
+    /**
+     * Document Symbols: Returns array of `DocumentSymbol` objects.
+     */
+    getDocumentSymbols(): any;
+    /**
+     * Hover: Returns `HoverInfo` object.
+     */
+    getHoverAtPosition(line: number, character: number): any;
+    /**
+     * Diagnostics: Get checker diagnostics in LSP format.
+     */
+    getLspDiagnostics(): any;
+    /**
+     * Get the number of nodes in the AST.
+     */
+    getNodeCount(): number;
+    /**
+     * Find References: Returns array of Location objects.
+     */
+    getReferencesAtPosition(line: number, character: number): any;
+    /**
+     * Rename - Edits: Get workspace edits for rename.
+     */
+    getRenameEdits(line: number, character: number, new_name: string): any;
+    /**
+     * Semantic Tokens: Returns flat array of u32 (delta encoded).
+     */
+    getSemanticTokens(): Uint32Array;
+    /**
+     * Signature Help: Returns `SignatureHelp` object.
+     */
+    getSignatureHelpAtPosition(line: number, character: number): any;
+    /**
+     * Get the type of a node as a string.
+     */
+    getTypeOfNode(node_idx: number): string;
+    /**
+     * Create a new Parser for the given source file.
+     */
+    constructor(file_name: string, source_text: string);
+    /**
+     * Parse the source file and return the root node index.
+     */
+    parseSourceFile(): number;
+    /**
+     * Rename - Prepare: Check if rename is valid at position.
+     */
+    prepareRename(line: number, character: number): any;
+    /**
+     * Set compiler options from JSON.
+     *
+     * # Arguments
+     * * `options_json` - JSON string containing compiler options
+     *
+     * # Example
+     * ```javascript
+     * const parser = new Parser("file.ts", "const x = 1;");
+     * parser.setCompilerOptions(JSON.stringify({
+     *   strict: true,
+     *   noImplicitAny: true,
+     *   strictNullChecks: true
+     * }));
+     * ```
+     */
+    setCompilerOptions(options_json: string): void;
+    /**
+     * Trace the parent chain for a node at a given position
+     */
+    traceParentChain(pos: number): string;
+}
+
+/**
+ * The scanner state that holds the current position and token information.
+ *
+ * ZERO-COPY OPTIMIZATION: Source is stored as UTF-8 text directly (no Vec<char>).
+ * For ASCII-only files (99% of TypeScript), byte position == character position.
+ * Positions are byte-based internally for performance, converted when needed.
+ */
+export class ScannerState {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Get the current position (end position of current token).
+     */
+    getPos(): number;
+    /**
+     * Get the source text.
+     */
+    getText(): string;
+    /**
+     * Get the current token kind.
+     */
+    getToken(): SyntaxKind;
+    /**
+     * Get the end position of the current token.
+     */
+    getTokenEnd(): number;
+    /**
+     * Get the token flags.
+     */
+    getTokenFlags(): number;
+    /**
+     * Get the full start position (including leading trivia).
+     */
+    getTokenFullStart(): number;
+    /**
+     * Get the start position of the current token (excluding trivia).
+     */
+    getTokenStart(): number;
+    /**
+     * Get the current token's text from the source.
+     */
+    getTokenText(): string;
+    /**
+     * Get the current token's string value.
+     * Note: Prefer `get_token_value_ref()` to avoid allocation when possible.
+     */
+    getTokenValue(): string;
+    /**
+     * Check if there was a preceding line break.
+     */
+    hasPrecedingLineBreak(): boolean;
+    /**
+     * Check if the current token is an identifier.
+     */
+    isIdentifier(): boolean;
+    /**
+     * Check if the current token is a reserved word.
+     */
+    isReservedWord(): boolean;
+    /**
+     * Check if the token is unterminated.
+     */
+    isUnterminated(): boolean;
+    /**
+     * Exported scanner accessors are JS bindings and cannot be made `const`
+     * because `#[wasm_bindgen]` methods in this crate are non-`const`.
+     * Create a new scanner state with the given text.
+     * ZERO-COPY: No Vec<char> allocation, works directly with UTF-8 bytes.
+     */
+    constructor(text: string, skip_trivia: boolean);
+    /**
+     * Re-scan the current `*=` token as `*` followed by `=`.
+     * Used when parsing computed property names.
+     */
+    reScanAsteriskEqualsToken(): SyntaxKind;
+    /**
+     * Re-scan the current `>` token to see if it should be `>=`, `>>`, `>>>`, `>>=`, or `>>>=`.
+     * This is used by the parser for type arguments and bitwise operators.
+     */
+    reScanGreaterToken(): SyntaxKind;
+    /**
+     * Re-scan the current `#` token as a hash token or private identifier.
+     */
+    reScanHashToken(): SyntaxKind;
+    /**
+     * Re-scan an invalid identifier to check if it's valid in a specific context.
+     */
+    reScanInvalidIdentifier(): SyntaxKind;
+    /**
+     * Re-scan a JSX attribute value from the current token position.
+     */
+    reScanJsxAttributeValue(): SyntaxKind;
+    /**
+     * Re-scan the current token as a JSX token.
+     * Used when the parser enters JSX context and needs to rescan.
+     */
+    reScanJsxToken(allow_multiline_jsx_text: boolean): SyntaxKind;
+    /**
+     * Re-scan a `<` token in JSX context.
+     * Returns `LessThanSlashToken` if followed by `/`, otherwise `LessThanToken`.
+     */
+    reScanLessThanToken(): SyntaxKind;
+    /**
+     * Re-scan the current `?` token for optional chaining.
+     */
+    reScanQuestionToken(): SyntaxKind;
+    /**
+     * Re-scan the current `/` or `/=` token as a regex literal.
+     * This is used by the parser when it determines the context requires a regex.
+     */
+    reScanSlashToken(): SyntaxKind;
+    /**
+     * Re-scan template head or no-substitution template.
+     * Used when the parser needs to rescan the start of a template.
+     */
+    reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind;
+    /**
+     * Re-scan the current `}` token as the continuation of a template literal.
+     * Called by the parser when it determines that a `}` is closing a template expression.
+     *
+     * # Arguments
+     * * `is_tagged_template` - If true, invalid escape sequences should not report errors
+     *   (tagged templates can have invalid escapes that get passed to the tag function as raw).
+     *   For now, we don't report errors anyway, so this parameter affects nothing.
+     */
+    reScanTemplateToken(_is_tagged_template: boolean): SyntaxKind;
+    /**
+     * Reset the token state to a specific position.
+     */
+    resetTokenState(new_pos: number): void;
+    /**
+     * Scan the next token.
+     */
+    scan(): SyntaxKind;
+    /**
+     * Scan `JSDoc` comment text token.
+     * Used for scanning the text content within `JSDoc` comments.
+     */
+    scanJsDocCommentTextToken(in_backticks: boolean): SyntaxKind;
+    /**
+     * Scan a `JSDoc` token.
+     * Used when parsing `JSDoc` comments.
+     */
+    scanJsDocToken(): SyntaxKind;
+    /**
+     * Scan a JSX attribute value (string literal or expression).
+     */
+    scanJsxAttributeValue(): SyntaxKind;
+    /**
+     * Scan a JSX identifier.
+     * In JSX, identifiers can contain hyphens (like `data-testid`).
+     */
+    scanJsxIdentifier(): SyntaxKind;
+    /**
+     * Scan a shebang (#!) at the start of the file.
+     * Returns the length of the shebang line (including newline), or 0 if no shebang.
+     */
+    scanShebangTrivia(): number;
+    /**
+     * Set the text to scan.
+     * ZERO-COPY: Works directly with UTF-8 bytes.
+     */
+    setText(text: string, start?: number | null, length?: number | null): void;
+    /**
+     * Set the current position (used for rescanning compound tokens).
+     * This allows consuming partial tokens like splitting `>>` into `>` + `>`.
+     */
+    set_pos(pos: number): void;
+}
+
+/**
+ * `ScriptKind` enum (file type)
+ */
+export enum ScriptKind {
+    Unknown = 0,
+    JS = 1,
+    JSX = 2,
+    TS = 3,
+    TSX = 4,
+    External = 5,
+    JSON = 6,
+    Deferred = 7,
+}
+
+/**
+ * `ScriptTarget` enum (ES version)
+ */
+export enum ScriptTarget {
+    ES3 = 0,
+    ES5 = 1,
+    ES2015 = 2,
+    ES2016 = 3,
+    ES2017 = 4,
+    ES2018 = 5,
+    ES2019 = 6,
+    ES2020 = 7,
+    ES2021 = 8,
+    ES2022 = 9,
+    ES2023 = 10,
+    ESNext = 99,
+    JSON = 100,
+}
+
+/**
+ * `SignatureKind` enum
+ */
+export enum SignatureKind {
+    Call = 0,
+    Construct = 1,
+}
+
+/**
+ * Syntax kind enum matching TypeScript's `SyntaxKind`.
+ * This enum contains only the token types produced by the scanner (0-186).
+ * AST node types are not included here.
+ */
+export enum SyntaxKind {
+    Unknown = 0,
+    EndOfFileToken = 1,
+    SingleLineCommentTrivia = 2,
+    MultiLineCommentTrivia = 3,
+    NewLineTrivia = 4,
+    WhitespaceTrivia = 5,
+    ShebangTrivia = 6,
+    ConflictMarkerTrivia = 7,
+    NonTextFileMarkerTrivia = 8,
+    NumericLiteral = 9,
+    BigIntLiteral = 10,
+    StringLiteral = 11,
+    JsxText = 12,
+    JsxTextAllWhiteSpaces = 13,
+    RegularExpressionLiteral = 14,
+    NoSubstitutionTemplateLiteral = 15,
+    TemplateHead = 16,
+    TemplateMiddle = 17,
+    TemplateTail = 18,
+    OpenBraceToken = 19,
+    CloseBraceToken = 20,
+    OpenParenToken = 21,
+    CloseParenToken = 22,
+    OpenBracketToken = 23,
+    CloseBracketToken = 24,
+    DotToken = 25,
+    DotDotDotToken = 26,
+    SemicolonToken = 27,
+    CommaToken = 28,
+    QuestionDotToken = 29,
+    LessThanToken = 30,
+    LessThanSlashToken = 31,
+    GreaterThanToken = 32,
+    LessThanEqualsToken = 33,
+    GreaterThanEqualsToken = 34,
+    EqualsEqualsToken = 35,
+    ExclamationEqualsToken = 36,
+    EqualsEqualsEqualsToken = 37,
+    ExclamationEqualsEqualsToken = 38,
+    EqualsGreaterThanToken = 39,
+    PlusToken = 40,
+    MinusToken = 41,
+    AsteriskToken = 42,
+    AsteriskAsteriskToken = 43,
+    SlashToken = 44,
+    PercentToken = 45,
+    PlusPlusToken = 46,
+    MinusMinusToken = 47,
+    LessThanLessThanToken = 48,
+    GreaterThanGreaterThanToken = 49,
+    GreaterThanGreaterThanGreaterThanToken = 50,
+    AmpersandToken = 51,
+    BarToken = 52,
+    CaretToken = 53,
+    ExclamationToken = 54,
+    TildeToken = 55,
+    AmpersandAmpersandToken = 56,
+    BarBarToken = 57,
+    QuestionToken = 58,
+    ColonToken = 59,
+    AtToken = 60,
+    QuestionQuestionToken = 61,
+    BacktickToken = 62,
+    HashToken = 63,
+    EqualsToken = 64,
+    PlusEqualsToken = 65,
+    MinusEqualsToken = 66,
+    AsteriskEqualsToken = 67,
+    AsteriskAsteriskEqualsToken = 68,
+    SlashEqualsToken = 69,
+    PercentEqualsToken = 70,
+    LessThanLessThanEqualsToken = 71,
+    GreaterThanGreaterThanEqualsToken = 72,
+    GreaterThanGreaterThanGreaterThanEqualsToken = 73,
+    AmpersandEqualsToken = 74,
+    BarEqualsToken = 75,
+    BarBarEqualsToken = 76,
+    AmpersandAmpersandEqualsToken = 77,
+    QuestionQuestionEqualsToken = 78,
+    CaretEqualsToken = 79,
+    Identifier = 80,
+    PrivateIdentifier = 81,
+    JSDocCommentTextToken = 82,
+    BreakKeyword = 83,
+    CaseKeyword = 84,
+    CatchKeyword = 85,
+    ClassKeyword = 86,
+    ConstKeyword = 87,
+    ContinueKeyword = 88,
+    DebuggerKeyword = 89,
+    DefaultKeyword = 90,
+    DeleteKeyword = 91,
+    DoKeyword = 92,
+    ElseKeyword = 93,
+    EnumKeyword = 94,
+    ExportKeyword = 95,
+    ExtendsKeyword = 96,
+    FalseKeyword = 97,
+    FinallyKeyword = 98,
+    ForKeyword = 99,
+    FunctionKeyword = 100,
+    IfKeyword = 101,
+    ImportKeyword = 102,
+    InKeyword = 103,
+    InstanceOfKeyword = 104,
+    NewKeyword = 105,
+    NullKeyword = 106,
+    ReturnKeyword = 107,
+    SuperKeyword = 108,
+    SwitchKeyword = 109,
+    ThisKeyword = 110,
+    ThrowKeyword = 111,
+    TrueKeyword = 112,
+    TryKeyword = 113,
+    TypeOfKeyword = 114,
+    VarKeyword = 115,
+    VoidKeyword = 116,
+    WhileKeyword = 117,
+    WithKeyword = 118,
+    ImplementsKeyword = 119,
+    InterfaceKeyword = 120,
+    LetKeyword = 121,
+    PackageKeyword = 122,
+    PrivateKeyword = 123,
+    ProtectedKeyword = 124,
+    PublicKeyword = 125,
+    StaticKeyword = 126,
+    YieldKeyword = 127,
+    AbstractKeyword = 128,
+    AccessorKeyword = 129,
+    AsKeyword = 130,
+    AssertsKeyword = 131,
+    AssertKeyword = 132,
+    AnyKeyword = 133,
+    AsyncKeyword = 134,
+    AwaitKeyword = 135,
+    BooleanKeyword = 136,
+    ConstructorKeyword = 137,
+    DeclareKeyword = 138,
+    GetKeyword = 139,
+    InferKeyword = 140,
+    IntrinsicKeyword = 141,
+    IsKeyword = 142,
+    KeyOfKeyword = 143,
+    ModuleKeyword = 144,
+    NamespaceKeyword = 145,
+    NeverKeyword = 146,
+    OutKeyword = 147,
+    ReadonlyKeyword = 148,
+    RequireKeyword = 149,
+    NumberKeyword = 150,
+    ObjectKeyword = 151,
+    SatisfiesKeyword = 152,
+    SetKeyword = 153,
+    StringKeyword = 154,
+    SymbolKeyword = 155,
+    TypeKeyword = 156,
+    UndefinedKeyword = 157,
+    UniqueKeyword = 158,
+    UnknownKeyword = 159,
+    UsingKeyword = 160,
+    FromKeyword = 161,
+    GlobalKeyword = 162,
+    BigIntKeyword = 163,
+    OverrideKeyword = 164,
+    OfKeyword = 165,
+    DeferKeyword = 166,
+}
+
+/**
+ * A text range with start and end positions.
+ * All positions are character indices (not byte indices).
+ */
+export class TextRange {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a new text range.
+     * All positions are character indices (not byte indices).
+     */
+    constructor(pos: number, end: number);
+    end: number;
+    pos: number;
+}
+
+/**
+ * Token flags indicating special properties of scanned tokens.
+ */
+export enum TokenFlags {
+    None = 0,
+    PrecedingLineBreak = 1,
+    PrecedingJSDocComment = 2,
+    Unterminated = 4,
+    ExtendedUnicodeEscape = 8,
+    Scientific = 16,
+    Octal = 32,
+    HexSpecifier = 64,
+    BinarySpecifier = 128,
+    OctalSpecifier = 256,
+    ContainsSeparator = 512,
+    UnicodeEscape = 1024,
+    ContainsInvalidEscape = 2048,
+    HexEscape = 4096,
+    ContainsLeadingZero = 8192,
+    ContainsInvalidSeparator = 16384,
+    PrecedingJSDocLeadingAsterisks = 32768,
+}
+
+/**
+ * TypeScript Diagnostic - represents a compiler diagnostic
+ *
+ * Contains:
+ * - file information (name, position)
+ * - message (text or chain)
+ * - category (error, warning, suggestion, message)
+ * - error code
+ */
+export class TsDiagnostic {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Check if this is an error
+     */
+    isError(): boolean;
+    /**
+     * Check if this is a warning
+     */
+    isWarning(): boolean;
+    /**
+     * Create a new diagnostic
+     */
+    constructor(file_name: string | null | undefined, start: number, length: number, message_text: string, category: DiagnosticCategory, code: number);
+    /**
+     * Convert to JSON
+     */
+    toJson(): string;
+    /**
+     * Get the category
+     */
+    readonly category: number;
+    /**
+     * Get the error code
+     */
+    readonly code: number;
+    /**
+     * Get the file name
+     */
+    readonly fileName: string | undefined;
+    /**
+     * Get the length
+     */
+    readonly length: number;
+    /**
+     * Get the message text
+     */
+    readonly messageText: string;
+    /**
+     * Get the start position
+     */
+    readonly start: number;
+}
+
+/**
+ * Language Service for a single file
+ *
+ * Provides IDE-like features for a TypeScript/JavaScript file.
+ */
+export class TsLanguageService {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Dispose resources
+     */
+    dispose(): void;
+    /**
+     * Get completions at a position
+     *
+     * # Arguments
+     * * `line` - 0-based line number
+     * * `character` - 0-based character offset
+     *
+     * # Returns
+     * JSON array of completion items
+     */
+    getCompletionsAtPosition(line: number, character: number): string;
+    /**
+     * Get definition location at a position
+     *
+     * # Arguments
+     * * `line` - 0-based line number
+     * * `character` - 0-based character offset
+     *
+     * # Returns
+     * JSON array of definition locations
+     */
+    getDefinitionAtPosition(line: number, character: number): string;
+    /**
+     * Get hover information at a position
+     *
+     * # Arguments
+     * * `line` - 0-based line number
+     * * `character` - 0-based character offset
+     *
+     * # Returns
+     * JSON with hover contents and range
+     */
+    getQuickInfoAtPosition(line: number, character: number): string;
+    /**
+     * Get references at a position
+     *
+     * # Arguments
+     * * `line` - 0-based line number
+     * * `character` - 0-based character offset
+     *
+     * # Returns
+     * JSON array of reference locations
+     */
+    getReferencesAtPosition(line: number, character: number): string;
+    /**
+     * Create a new language service for a file
+     */
+    constructor(file_name: string, source_text: string);
+    /**
+     * Update the source text and re-parse
+     */
+    updateSource(source_text: string): void;
+    /**
+     * Get the file name
+     */
+    readonly fileName: string;
+}
+
+/**
+ * TypeScript Program - the main compilation unit
+ *
+ * Represents a compiled TypeScript program with access to:
+ * - Source files
+ * - Diagnostics (syntactic and semantic)
+ * - Type checker
+ * - Emit functionality
+ */
+export class TsProgram {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a library file (lib.d.ts, lib.es5.d.ts, etc.)
+     */
+    addLibFile(file_name: string, source_text: string): void;
+    /**
+     * Add a source file to the program
+     */
+    addSourceFile(file_name: string, source_text: string): void;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+    /**
+     * Emit a single file by name
+     */
+    emitFile(file_name: string): string;
+    /**
+     * Emit JavaScript output for all files
+     */
+    emitJson(): string;
+    /**
+     * Get all diagnostic codes as array
+     */
+    getAllDiagnosticCodes(): Uint32Array;
+    /**
+     * Get compiler options as JSON
+     */
+    getCompilerOptionsJson(): string;
+    /**
+     * Get all diagnostics (syntactic + semantic) as JSON
+     */
+    getPreEmitDiagnosticsJson(): string;
+    /**
+     * Get source file names as JSON array
+     */
+    getRootFileNames(): any;
+    /**
+     * Get semantic diagnostics as JSON
+     */
+    getSemanticDiagnosticsJson(file_name?: string | null): string;
+    /**
+     * Get the number of source files
+     */
+    getSourceFileCount(): number;
+    /**
+     * Get syntactic diagnostics as JSON
+     */
+    getSyntacticDiagnosticsJson(file_name?: string | null): string;
+    /**
+     * Get the type checker
+     *
+     * Returns a handle to the type checker for this program.
+     * The type checker provides type information and type-related operations.
+     */
+    getTypeChecker(): TsTypeChecker;
+    /**
+     * Create a new empty program
+     */
+    constructor();
+    /**
+     * Set compiler options from JSON
+     */
+    setCompilerOptions(options_json: string): void;
+}
+
+/**
+ * TypeScript Signature - represents a call/construct signature
+ *
+ * Signatures have:
+ * - parameters
+ * - return type
+ * - type parameters (for generic signatures)
+ */
+export class TsSignature {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Get declaration node handle
+     */
+    getDeclarationHandle(): number | undefined;
+    /**
+     * Get parameter symbol handles
+     */
+    getParameterHandles(): Uint32Array;
+    /**
+     * Get type parameter handles
+     */
+    getTypeParameterHandles(): Uint32Array;
+    /**
+     * Create a new signature wrapper
+     */
+    constructor(handle: number);
+    /**
+     * Get the signature handle
+     */
+    readonly handle: number;
+}
+
+/**
+ * TypeScript `SourceFile` - represents a parsed source file
+ *
+ * Provides access to:
+ * - File metadata (name, text, language version)
+ * - AST root and statements
+ * - Node traversal methods
+ */
+export class TsSourceFile {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Iterate over children (returns child handles as JSON array)
+     */
+    forEachChild(handle: number): any;
+    /**
+     * Get children of a node
+     */
+    getChildHandles(handle: number): Uint32Array;
+    /**
+     * Get identifier text for an identifier node
+     */
+    getIdentifierText(handle: number): string | undefined;
+    /**
+     * Get node end position
+     */
+    getNodeEnd(handle: number): number;
+    /**
+     * Get node flags
+     */
+    getNodeFlags(handle: number): number;
+    /**
+     * Get node kind by handle
+     */
+    getNodeKind(handle: number): number;
+    /**
+     * Get node start position
+     */
+    getNodePos(handle: number): number;
+    /**
+     * Get node text (substring from source)
+     */
+    getNodeText(handle: number): string;
+    /**
+     * Get parent node handle
+     */
+    getParentHandle(handle: number): number;
+    /**
+     * Get the root node handle
+     */
+    getRootHandle(): number;
+    /**
+     * Get statement handles (children of source file)
+     */
+    getStatementHandles(): Uint32Array;
+    /**
+     * Check if a node is a specific kind
+     */
+    isKind(handle: number, kind: number): boolean;
+    /**
+     * Create a new source file by parsing the given text
+     */
+    constructor(file_name: string, source_text: string);
+    /**
+     * Get the end position (length of text)
+     */
+    readonly end: number;
+    /**
+     * Get the file name
+     */
+    readonly fileName: string;
+    /**
+     * Check if this is a declaration file
+     */
+    readonly isDeclarationFile: boolean;
+    /**
+     * Get the kind (always `SourceFile`)
+     */
+    readonly kind: number;
+    /**
+     * Get the language version
+     */
+    readonly languageVersion: ScriptTarget;
+    /**
+     * Get the start position (always 0)
+     */
+    readonly pos: number;
+    /**
+     * Get the script kind
+     */
+    readonly scriptKind: ScriptKind;
+    /**
+     * Get the source text
+     */
+    readonly text: string;
+}
+
+/**
+ * TypeScript Symbol - represents a named entity
+ *
+ * Symbols have:
+ * - name (escaped name for identifiers)
+ * - flags (`SymbolFlags` bits)
+ * - declarations (AST nodes where declared)
+ * - value declaration (primary declaration)
+ */
+export class TsSymbol {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * r" Check if this is an alias (import) symbol
+     */
+    isAlias(): boolean;
+    /**
+     * r" Check if this is a class symbol
+     */
+    isClass(): boolean;
+    /**
+     * r" Check if this is an enum symbol
+     */
+    isEnum(): boolean;
+    /**
+     * r" Check if this is a function symbol
+     */
+    isFunction(): boolean;
+    /**
+     * r" Check if this is an interface symbol
+     */
+    isInterface(): boolean;
+    /**
+     * r" Check if this is a method symbol
+     */
+    isMethod(): boolean;
+    /**
+     * r" Check if this symbol is optional
+     */
+    isOptional(): boolean;
+    /**
+     * r" Check if this is a property symbol
+     */
+    isProperty(): boolean;
+    /**
+     * r" Check if this is a type alias symbol
+     */
+    isTypeAlias(): boolean;
+    /**
+     * r" Check if this is a type parameter symbol
+     */
+    isTypeParameter(): boolean;
+    /**
+     * r" Check if this is a variable symbol
+     */
+    isVariable(): boolean;
+    /**
+     * Create a new symbol wrapper
+     */
+    constructor(handle: number, flags: number, name: string);
+    /**
+     * Get escaped name (same as name for most identifiers)
+     */
+    readonly escapedName: string;
+    /**
+     * Get symbol flags
+     */
+    readonly flags: number;
+    /**
+     * Get the symbol handle
+     */
+    readonly handle: number;
+    /**
+     * Get symbol name
+     */
+    readonly name: string;
+}
+
+/**
+ * TypeScript Type - represents a type in the type system
+ *
+ * Types are identified by handles (`TypeId`) and have:
+ * - flags (`TypeFlags` bits)
+ * - optional symbol
+ * - various type-specific properties
+ */
+export class TsType {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * r" Check if this is `any` type
+     */
+    isAny(): boolean;
+    /**
+     * r" Check if this is `boolean` type
+     */
+    isBoolean(): boolean;
+    /**
+     * Check if this type is a class or interface
+     */
+    isClassOrInterface(): boolean;
+    /**
+     * r" Check if this is an intersection type
+     */
+    isIntersection(): boolean;
+    /**
+     * Check if this is a literal type
+     */
+    isLiteral(): boolean;
+    /**
+     * r" Check if this is `never` type
+     */
+    isNever(): boolean;
+    /**
+     * r" Check if this is `null` type
+     */
+    isNull(): boolean;
+    /**
+     * r" Check if this is `number` type
+     */
+    isNumber(): boolean;
+    /**
+     * r" Check if this is a number literal type
+     */
+    isNumberLiteral(): boolean;
+    /**
+     * r" Check if this is an object type
+     */
+    isObject(): boolean;
+    /**
+     * r" Check if this is `string` type
+     */
+    isString(): boolean;
+    /**
+     * r" Check if this is a string literal type
+     */
+    isStringLiteral(): boolean;
+    /**
+     * r" Check if this is a type parameter
+     */
+    isTypeParameter(): boolean;
+    /**
+     * r" Check if this is `undefined` type
+     */
+    isUndefined(): boolean;
+    /**
+     * r" Check if this is a union type
+     */
+    isUnion(): boolean;
+    /**
+     * Check if this is a union or intersection
+     */
+    isUnionOrIntersection(): boolean;
+    /**
+     * r" Check if this is `unknown` type
+     */
+    isUnknown(): boolean;
+    /**
+     * r" Check if this is `void` type
+     */
+    isVoid(): boolean;
+    /**
+     * Create a new type wrapper
+     */
+    constructor(handle: number, flags: number);
+    /**
+     * Get type flags
+     */
+    readonly flags: number;
+    /**
+     * Get the type handle
+     */
+    readonly handle: number;
+}
+
+/**
+ * TypeScript `TypeChecker` - provides type information
+ *
+ * The type checker is the primary interface for querying type information
+ * from a program. It provides methods like:
+ * - `getTypeAtLocation(node)` - Get the type of an AST node
+ * - `getSymbolAtLocation(node)` - Get the symbol for an identifier
+ * - `typeToString(type)` - Format a type for display
+ * - `isTypeAssignableTo(source, target)` - Check assignability
+ */
+export class TsTypeChecker {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * r" Get the `any` type
+     */
+    getAnyType(): number;
+    /**
+     * Get the apparent type (handles widening, etc.)
+     */
+    getApparentType(type_handle: number): number;
+    /**
+     * Get base types (for classes/interfaces)
+     */
+    getBaseTypes(_type_handle: number): Uint32Array;
+    /**
+     * r" Get the `boolean` type
+     */
+    getBooleanType(): number;
+    /**
+     * Get the declared type of a symbol
+     */
+    getDeclaredTypeOfSymbol(_symbol_handle: number): number;
+    /**
+     * r" Get the `false` literal type
+     */
+    getFalseType(): number;
+    /**
+     * Get the fully qualified name of a symbol
+     */
+    getFullyQualifiedName(_symbol_handle: number): string;
+    /**
+     * r" Get the `never` type
+     */
+    getNeverType(): number;
+    /**
+     * r" Get the `null` type
+     */
+    getNullType(): number;
+    /**
+     * r" Get the `number` type
+     */
+    getNumberType(): number;
+    /**
+     * Get properties of a type
+     *
+     * Returns handles to symbol objects
+     */
+    getPropertiesOfType(_type_handle: number): Uint32Array;
+    /**
+     * Get a specific property of a type by name
+     */
+    getPropertyOfType(_type_handle: number, _property_name: string): number | undefined;
+    /**
+     * Get return type of a signature
+     */
+    getReturnTypeOfSignature(_signature_handle: number): number;
+    /**
+     * Get call signatures of a type
+     */
+    getSignaturesOfType(_type_handle: number, _kind: SignatureKind): Uint32Array;
+    /**
+     * r" Get the `string` type
+     */
+    getStringType(): number;
+    /**
+     * Get the symbol at a specific AST node location
+     *
+     * # Arguments
+     * * `node_handle` - Handle (index) of the AST node
+     *
+     * # Returns
+     * Handle (ID) of the symbol, or `u32::MAX` if none
+     */
+    getSymbolAtLocation(_node_handle: number): number;
+    /**
+     * Get symbol flags
+     */
+    getSymbolFlags(_symbol_handle: number): number;
+    /**
+     * r" Get the `true` literal type
+     */
+    getTrueType(): number;
+    /**
+     * Get the type at a specific AST node location
+     *
+     * # Arguments
+     * * `node_handle` - Handle (index) of the AST node
+     *
+     * # Returns
+     * Handle (ID) of the type, or 0 for error type
+     */
+    getTypeAtLocation(_node_handle: number): number;
+    /**
+     * Get type flags
+     */
+    getTypeFlags(type_handle: number): number;
+    /**
+     * Get the type of a symbol
+     */
+    getTypeOfSymbol(_symbol_handle: number): number;
+    /**
+     * r" Get the `undefined` type
+     */
+    getUndefinedType(): number;
+    /**
+     * r" Get the `unknown` type
+     */
+    getUnknownType(): number;
+    /**
+     * r" Get the `void` type
+     */
+    getVoidType(): number;
+    /**
+     * Check if type is an array type
+     */
+    isArrayType(_type_handle: number): boolean;
+    /**
+     * Check if type is an intersection type
+     */
+    isIntersectionType(_type_handle: number): boolean;
+    /**
+     * Check if type is nullable (includes null or undefined)
+     */
+    isNullableType(type_handle: number): boolean;
+    /**
+     * Check if type is a tuple type
+     */
+    isTupleType(_type_handle: number): boolean;
+    /**
+     * Check if source type is assignable to target type
+     */
+    isTypeAssignableTo(source: number, target: number): boolean;
+    /**
+     * Check if type is a type parameter
+     */
+    isTypeParameter(_type_handle: number): boolean;
+    /**
+     * Check if type is a union type
+     */
+    isUnionType(_type_handle: number): boolean;
+    /**
+     * Format a symbol as a string
+     */
+    symbolToString(_symbol_handle: number): string;
+    /**
+     * Format a type as a string
+     */
+    typeToString(type_handle: number): string;
+}
+
+/**
+ * Parallel type checker using the shared `TypeInterner`.
+ *
+ * This enables parallel type checking of function bodies across multiple files
+ * while sharing a single type interner for deduplication.
+ */
+export class WasmParallelChecker {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a file to be checked.
+     */
+    addFile(file_name: string, source_text: string): void;
+    /**
+     * Compile and check all files in parallel.
+     *
+     * This performs:
+     * 1. Parallel parsing of all files
+     * 2. Parallel binding to create symbols
+     * 3. Sequential merging of symbol tables
+     * 4. Parallel type checking of function bodies
+     *
+     * This function catches panics to prevent WASM crashes.
+     */
+    checkAll(): any;
+    /**
+     * Clear all files.
+     */
+    clear(): void;
+    /**
+     * Get the number of files added.
+     */
+    getFileCount(): number;
+    /**
+     * Create a new parallel checker.
+     */
+    constructor();
+}
+
+/**
+ * Parallel file parser using rayon's work-stealing scheduler.
+ *
+ * This provides high-performance parallel parsing of multiple TypeScript files.
+ * Each file is parsed independently, producing its own AST arena.
+ */
+export class WasmParallelParser {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a file to be parsed.
+     */
+    addFile(file_name: string, source_text: string): void;
+    /**
+     * Clear all files.
+     */
+    clear(): void;
+    /**
+     * Get the number of files added.
+     */
+    getFileCount(): number;
+    /**
+     * Create a new parallel parser.
+     */
+    constructor();
+    /**
+     * Parse all files in parallel and return statistics.
+     *
+     * This function catches panics to prevent WASM crashes.
+     */
+    parseAll(): any;
+}
+
+/**
+ * Multi-file TypeScript program for cross-file type checking.
+ *
+ * This struct provides an API for compiling multiple TypeScript files together,
+ * enabling proper module resolution and cross-file type checking.
+ *
+ * # Example (JavaScript)
+ * ```javascript
+ * const program = new WasmProgram();
+ * program.addFile("a.ts", "export const x = 1;");
+ * program.addFile("b.ts", "import { x } from './a'; const y = x + 1;");
+ * const result = program.checkAll();
+ * console.log(result);
+ * ```
+ */
+export class WasmProgram {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a file to the program.
+     *
+     * Files are accumulated and compiled together when `checkAll` is called.
+     * The `file_name` should be a relative path like "src/a.ts".
+     *
+     * For TypeScript library files (lib.d.ts, lib.dom.d.ts, etc.), use `addLibFile` instead.
+     */
+    addFile(file_name: string, source_text: string): void;
+    /**
+     * Add a TypeScript library file (lib.d.ts, lib.dom.d.ts, etc.) to the program.
+     *
+     * Lib files are used for global symbol resolution and are merged into
+     * the symbol table before user files are processed.
+     *
+     * Use this method explicitly instead of relying on automatic file name detection.
+     * This makes the API behavior predictable and explicit.
+     *
+     * # Example (JavaScript)
+     * ```javascript
+     * const program = new WasmProgram();
+     * program.addLibFile("lib.d.ts", libContent);
+     * program.addFile("src/a.ts", userCode);
+     * ```
+     */
+    addLibFile(file_name: string, source_text: string): void;
+    /**
+     * Compile all files and return diagnostics as JSON.
+     *
+     * This performs:
+     * 1. Load lib files for global symbol resolution
+     * 2. Parallel parsing of all files
+     * 3. Parallel binding of all files with lib symbols merged
+     * 4. Symbol merging (sequential)
+     * 5. Parallel type checking
+     *
+     * Returns a JSON object with diagnostics per file.
+     */
+    checkAll(): string;
+    /**
+     * Clear all files and reset the program state.
+     */
+    clear(): void;
+    /**
+     * Get all diagnostic codes as a flat array (for simple conformance comparison).
+     *
+     * This combines all parse and check diagnostics from all files into a single
+     * array of error codes, which can be compared against tsc output.
+     */
+    getAllDiagnosticCodes(): Uint32Array;
+    /**
+     * Get diagnostic codes for all files (for conformance testing).
+     *
+     * Returns a JSON object mapping file names to arrays of error codes.
+     */
+    getDiagnosticCodes(): string;
+    /**
+     * Get the number of files in the program.
+     */
+    getFileCount(): number;
+    /**
+     * Create a new empty program.
+     */
+    constructor();
+    /**
+     * Set compiler options from JSON.
+     *
+     * # Arguments
+     * * `options_json` - JSON string containing compiler options
+     */
+    setCompilerOptions(options_json: string): void;
+}
+
+/**
+ * Opaque wrapper for transform directives across the wasm boundary.
+ */
+export class WasmTransformContext {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Get the number of transform directives generated.
+     */
+    getCount(): number;
+}
+
+/**
+ * WASM-compatible type interner for parallel type checking.
+ *
+ * This wraps the internal `TypeInterner` with a `wasm-bindgen` compatible interface.
+ * The underlying interner uses lock-free `DashMap` storage for concurrent access.
+ */
+export class WasmTypeInterner {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Get the number of interned types.
+     */
+    getTypeCount(): number;
+    /**
+     * Intern a string and return its atom ID.
+     */
+    internString(s: string): number;
+    /**
+     * Check if the interner is empty (only has intrinsics).
+     */
+    isEmpty(): boolean;
+    /**
+     * Create a new type interner with pre-registered intrinsics.
+     */
+    constructor();
+    /**
+     * Resolve an atom ID back to its string value.
+     */
+    resolveAtom(atom_id: number): string;
+}
+
+/**
+ * Compare two strings using a case-insensitive ordinal comparison.
+ *
+ * Case-insensitive comparisons compare both strings one code-point at a time using
+ * the integer value of each code-point after applying `to_uppercase` to each string.
+ * We always map both strings to their upper-case form as some unicode characters do
+ * not properly round-trip to lowercase (such as `ẞ` German sharp capital s).
+ */
+export function compareStringsCaseInsensitive(a?: string | null, b?: string | null): Comparison;
+
+/**
+ * Compare two strings using a case-insensitive ordinal comparison (eslint-compatible).
+ *
+ * This uses `to_lowercase` instead of `to_uppercase` to match eslint's `sort-imports`
+ * rule behavior. The difference affects the relative order of letters and ASCII
+ * characters 91-96, of which `_` is a valid identifier character.
+ */
+export function compareStringsCaseInsensitiveEslintCompatible(a?: string | null, b?: string | null): Comparison;
+
+/**
+ * Compare two strings using a case-sensitive ordinal comparison.
+ *
+ * Ordinal comparisons are based on the difference between the unicode code points
+ * of both strings. Characters with multiple unicode representations are considered
+ * unequal. Ordinal comparisons provide predictable ordering, but place "a" after "B".
+ */
+export function compareStringsCaseSensitive(a?: string | null, b?: string | null): Comparison;
+
+/**
+ * r" Create the `any` type
+ */
+export function createAnyType(): TsType;
+
+/**
+ * r" Create the `boolean` type
+ */
+export function createBooleanType(): TsType;
+
+/**
+ * Create a language service for a file
+ */
+export function createLanguageService(file_name: string, source_text: string): TsLanguageService;
+
+/**
+ * r" Create the `never` type
+ */
+export function createNeverType(): TsType;
+
+/**
+ * r" Create the `null` type
+ */
+export function createNullType(): TsType;
+
+/**
+ * r" Create the `number` type
+ */
+export function createNumberType(): TsType;
+
+/**
+ * Create a new Parser for the given source text.
+ * This is the recommended parser for production use.
+ */
+export function createParser(file_name: string, source_text: string): Parser;
+
+/**
+ * Create a new multi-file program.
+ */
+export function createProgram(): WasmProgram;
+
+/**
+ * Create a new scanner for the given source text.
+ * This is the wasm-bindgen entry point for creating scanners from JavaScript.
+ */
+export function createScanner(text: string, skip_trivia: boolean): ScannerState;
+
+/**
+ * Create a source file (parse only, no binding)
+ *
+ * This is a lightweight way to parse a file without full program creation.
+ */
+export function createSourceFile(file_name: string, source_text: string, _target?: number | null): TsSourceFile;
+
+/**
+ * r" Create the `string` type
+ */
+export function createStringType(): TsType;
+
+/**
+ * Create a TypeScript program (factory function)
+ *
+ * This is the main entry point for creating a program.
+ *
+ * # Arguments
+ * * `root_names_json` - JSON array of file names
+ * * `options_json` - JSON object with compiler options
+ * * `files_json` - JSON object mapping file names to content
+ *
+ * # Returns
+ * A new `TsProgram` instance
+ */
+export function createTsProgram(root_names_json: string, options_json: string, files_json: string): TsProgram;
+
+/**
+ * Create a source file (factory function)
+ */
+export function createTsSourceFile(file_name: string, source_text: string, language_version: ScriptTarget): TsSourceFile;
+
+/**
+ * r" Create the `undefined` type
+ */
+export function createUndefinedType(): TsType;
+
+/**
+ * r" Create the `unknown` type
+ */
+export function createUnknownType(): TsType;
+
+/**
+ * r" Create the `void` type
+ */
+export function createVoidType(): TsType;
+
+/**
+ * Get diagnostic category name
+ */
+export function diagnosticCategoryName(category: DiagnosticCategory): string;
+
+/**
+ * Ensures a path has a trailing directory separator.
+ */
+export function ensureTrailingDirectorySeparator(path: string): string;
+
+/**
+ * Check if two strings are equal (case-insensitive).
+ * Uses iterator-based comparison to avoid allocating new strings.
+ */
+export function equateStringsCaseInsensitive(a: string, b: string): boolean;
+
+/**
+ * Check if two strings are equal (case-sensitive).
+ */
+export function equateStringsCaseSensitive(a: string, b: string): boolean;
+
+/**
+ * Check if path ends with a specific extension.
+ */
+export function fileExtensionIs(path: string, extension: string): boolean;
+
+/**
+ * Flatten diagnostic message chain to a single string
+ *
+ * TypeScript diagnostics can have chained messages (messageText can be
+ * a chain). This flattens them to a single string.
+ */
+export function flattenDiagnosticMessageText(message_text: string, _new_line: string): string;
+
+/**
+ * Format a diagnostic to a string
+ */
+export function formatDiagnostic(diagnostic_json: string): string;
+
+/**
+ * Format diagnostics with color and context
+ */
+export function formatDiagnosticsWithColorAndContext(diagnostics_json: string, source_text: string): string;
+
+/**
+ * Format a diagnostic to a string
+ *
+ * Matches TypeScript's `formatDiagnostic` output format.
+ */
+export function formatTsDiagnostic(diagnostic: TsDiagnostic, new_line: string): string;
+
+/**
+ * Format diagnostics with color and context
+ *
+ * Provides pretty-printed output with:
+ * - ANSI colors (if terminal supports it)
+ * - Source code context around the error
+ * - Squiggle underlining
+ */
+export function formatTsDiagnosticsWithColorAndContext(diagnostics_json: string, source_files_json: string, use_colors: boolean): string;
+
+/**
+ * Returns the path except for its containing directory name (basename).
+ * Uses char-based operations for UTF-8 safety.
+ */
+export function getBaseFileName(path: string): string;
+
+/**
+ * Get the operator precedence for a binary operator
+ */
+export function getOperatorPrecedence(operator_kind: number): number;
+
+/**
+ * Get the tsz version
+ */
+export function getTszVersion(): string;
+
+/**
+ * Get the TypeScript version this is compatible with
+ */
+export function getTypeScriptVersion(): string;
+
+/**
+ * Determines whether a path has an extension.
+ */
+export function hasExtension(file_name: string): boolean;
+
+/**
+ * Determines whether a path has a trailing separator (`/` or `\\`).
+ */
+export function hasTrailingDirectorySeparator(path: string): boolean;
+
+/**
+ * Check if character is an ASCII letter (A-Z, a-z).
+ */
+export function isASCIILetter(ch: number): boolean;
+
+/**
+ * Determines whether a charCode corresponds to `/` or `\`.
+ */
+export function isAnyDirectorySeparator(char_code: number): boolean;
+
+/**
+ * r" Check if node is an array type
+ */
+export function isArrayTypeNode(kind: number): boolean;
+
+/**
+ * r" Check if node is an arrow function
+ */
+export function isArrowFunction(kind: number): boolean;
+
+/**
+ * r" Check if node is a binary expression
+ */
+export function isBinaryExpression(kind: number): boolean;
+
+/**
+ * r" Check if node is a block
+ */
+export function isBlock(kind: number): boolean;
+
+/**
+ * r" Check if node is a call expression
+ */
+export function isCallExpression(kind: number): boolean;
+
+/**
+ * r" Check if node is a class declaration
+ */
+export function isClassDeclaration(kind: number): boolean;
+
+/**
+ * r" Check if node is a class expression
+ */
+export function isClassExpression(kind: number): boolean;
+
+/**
+ * Check if node is any class-like
+ */
+export function isClassLike(kind: number): boolean;
+
+/**
+ * r" Check if node is a constructor
+ */
+export function isConstructorDeclaration(kind: number): boolean;
+
+/**
+ * Check if node is a declaration
+ */
+export function isDeclaration(kind: number): boolean;
+
+/**
+ * Check if character is a decimal digit (0-9).
+ */
+export function isDigit(ch: number): boolean;
+
+/**
+ * r" Check if node is an element access expression
+ */
+export function isElementAccessExpression(kind: number): boolean;
+
+/**
+ * r" Check if node is an enum declaration
+ */
+export function isEnumDeclaration(kind: number): boolean;
+
+/**
+ * r" Check if node is an export declaration
+ */
+export function isExportDeclaration(kind: number): boolean;
+
+/**
+ * Check if node is an expression
+ */
+export function isExpression(kind: number): boolean;
+
+/**
+ * r" Check if node is an expression statement
+ */
+export function isExpressionStatement(kind: number): boolean;
+
+/**
+ * r" Check if node is a for statement
+ */
+export function isForStatement(kind: number): boolean;
+
+/**
+ * r" Check if node is a function declaration
+ */
+export function isFunctionDeclaration(kind: number): boolean;
+
+/**
+ * r" Check if node is a function expression
+ */
+export function isFunctionExpression(kind: number): boolean;
+
+/**
+ * Check if node is any function-like
+ */
+export function isFunctionLike(kind: number): boolean;
+
+/**
+ * Check if character is a hexadecimal digit (0-9, A-F, a-f).
+ */
+export function isHexDigit(ch: number): boolean;
+
+/**
+ * r" Check if node is an identifier
+ */
+export function isIdentifier(kind: number): boolean;
+
+/**
+ * r" Check if node is an if statement
+ */
+export function isIfStatement(kind: number): boolean;
+
+/**
+ * r" Check if node is an import declaration
+ */
+export function isImportDeclaration(kind: number): boolean;
+
+/**
+ * r" Check if node is an interface declaration
+ */
+export function isInterfaceDeclaration(kind: number): boolean;
+
+/**
+ * r" Check if node is an intersection type
+ */
+export function isIntersectionTypeNode(kind: number): boolean;
+
+/**
+ * Check if a kind is a keyword
+ */
+export function isKeyword(kind: number): boolean;
+
+/**
+ * Check if character is a line break (LF, CR, LS, PS).
+ */
+export function isLineBreak(ch: number): boolean;
+
+/**
+ * Check if a kind is a literal expression
+ */
+export function isLiteralExpression(kind: number): boolean;
+
+/**
+ * r" Check if node is a method declaration
+ */
+export function isMethodDeclaration(kind: number): boolean;
+
+/**
+ * r" Check if node is a module/namespace declaration
+ */
+export function isModuleDeclaration(kind: number): boolean;
+
+/**
+ * r" Check if node is a new expression
+ */
+export function isNewExpression(kind: number): boolean;
+
+/**
+ * r" Check if node is a numeric literal
+ */
+export function isNumericLiteral(kind: number): boolean;
+
+/**
+ * Check if character is an octal digit (0-7).
+ */
+export function isOctalDigit(ch: number): boolean;
+
+/**
+ * r" Check if node is a parameter
+ */
+export function isParameter(kind: number): boolean;
+
+/**
+ * r" Check if node is a property access expression
+ */
+export function isPropertyAccessExpression(kind: number): boolean;
+
+/**
+ * r" Check if node is a property declaration
+ */
+export function isPropertyDeclaration(kind: number): boolean;
+
+/**
+ * Check if a kind is a punctuation token
+ */
+export function isPunctuation(kind: number): boolean;
+
+/**
+ * r" Check if node is a return statement
+ */
+export function isReturnStatement(kind: number): boolean;
+
+/**
+ * Check if node is a statement
+ */
+export function isStatement(kind: number): boolean;
+
+/**
+ * r" Check if node is a string literal
+ */
+export function isStringLiteral(kind: number): boolean;
+
+/**
+ * Check if a kind is a template literal token
+ */
+export function isTemplateLiteralKind(kind: number): boolean;
+
+/**
+ * Check if a kind is a trivia (whitespace, comment)
+ */
+export function isTrivia(kind: number): boolean;
+
+/**
+ * r" Check if node is a type alias declaration
+ */
+export function isTypeAliasDeclaration(kind: number): boolean;
+
+/**
+ * r" Check if node is a type reference
+ */
+export function isTypeReferenceNode(kind: number): boolean;
+
+/**
+ * r" Check if node is a union type
+ */
+export function isUnionTypeNode(kind: number): boolean;
+
+/**
+ * r" Check if node is a variable declaration
+ */
+export function isVariableDeclaration(kind: number): boolean;
+
+/**
+ * r" Check if node is a variable statement
+ */
+export function isVariableStatement(kind: number): boolean;
+
+/**
+ * r" Check if node is a while statement
+ */
+export function isWhileStatement(kind: number): boolean;
+
+/**
+ * Check if character is any whitespace (including line breaks).
+ */
+export function isWhiteSpaceLike(ch: number): boolean;
+
+/**
+ * Check if character is a single-line whitespace (not including line breaks).
+ */
+export function isWhiteSpaceSingleLine(ch: number): boolean;
+
+/**
+ * Check if character is a word character (A-Z, a-z, 0-9, _).
+ */
+export function isWordCharacter(ch: number): boolean;
+
+/**
+ * Get the text representation of a keyword token.
+ * WASM-exported version that allocates a String for JS compatibility.
+ */
+export function keywordToText(token: SyntaxKind): string | undefined;
+
+/**
+ * Normalize path separators, converting `\` into `/`.
+ */
+export function normalizeSlashes(path: string): string;
+
+/**
+ * Parse a JSON configuration file (tsconfig.json, etc.)
+ */
+export function parseConfigFileTextToJson(file_name: string, json_text: string): string;
+
+/**
+ * Parse JSON with comments (JSONC)
+ */
+export function parseJsonText(json_text: string): string;
+
+/**
+ * Determines whether a path starts with a relative path component (i.e. `.` or `..`).
+ */
+export function pathIsRelative(path: string): boolean;
+
+/**
+ * Get the text representation of a punctuation token.
+ * WASM-exported version that allocates a String for JS compatibility.
+ */
+export function punctuationToText(token: SyntaxKind): string | undefined;
+
+/**
+ * Removes a trailing directory separator from a path, if it has one.
+ * Uses char-based operations for UTF-8 safety.
+ */
+export function removeTrailingDirectorySeparator(path: string): string;
+
+/**
+ * Scan/tokenize source text using a source file
+ *
+ * Returns JSON array of tokens extracted from the parsed AST
+ */
+export function scanTokens(source_text: string): string;
+
+/**
+ * Get the token kind for a given text, including identifiers and keywords.
+ * Returns `Identifier` if the text is not a keyword.
+ */
+export function stringToToken(text: string): SyntaxKind;
+
+/**
+ * Get the name of a `SyntaxKind`
+ */
+export function syntaxKindToName(kind: number): string;
+
+/**
+ * Convert a string to its keyword `SyntaxKind`, if it's a keyword.
+ * Returns None if the text is not a keyword.
+ */
+export function textToKeyword(text: string): SyntaxKind | undefined;
+
+/**
+ * Convert file name to lowercase for case-insensitive file systems.
+ *
+ * This function handles special Unicode characters that need to remain
+ * case-sensitive for proper cross-platform file name handling:
+ * - \u{0130} (İ - Latin capital I with dot above)
+ * - \u{0131} (ı - Latin small letter dotless i)
+ * - \u{00DF} (ß - Latin small letter sharp s)
+ *
+ * These characters are excluded from lowercase conversion to maintain
+ * compatibility with case-insensitive file systems that have special
+ * handling for these characters (notably Turkish locale on Windows).
+ *
+ * Matches TypeScript's `toFileNameLowerCase` in src/compiler/core.ts
+ */
+export function toFileNameLowerCase(x: string): string;
+
+export function tokenIsAssignmentOperator(token: SyntaxKind): boolean;
+
+export function tokenIsIdentifierOrKeyword(token: SyntaxKind): boolean;
+
+export function tokenIsKeyword(token: SyntaxKind): boolean;
+
+export function tokenIsLiteral(token: SyntaxKind): boolean;
+
+export function tokenIsPunctuation(token: SyntaxKind): boolean;
+
+export function tokenIsReservedWord(token: SyntaxKind): boolean;
+
+export function tokenIsStrictModeReservedWord(token: SyntaxKind): boolean;
+
+export function tokenIsTemplateLiteral(token: SyntaxKind): boolean;
+
+export function tokenIsTrivia(token: SyntaxKind): boolean;
+
+/**
+ * Get the text of a token kind (for operators, keywords)
+ */
+export function tokenToString(kind: number): string | undefined;
+
+/**
+ * Transpile TypeScript to JavaScript (simple version)
+ *
+ * Returns just the JavaScript output string for quick use.
+ */
+export function transpile(source: string, target?: number | null, module?: number | null): string;
+
+/**
+ * Transpile a single TypeScript file to JavaScript
+ *
+ * This is a simplified API for quick transpilation without creating a full program.
+ */
+export function transpileModule(source: string, options_json: string): string;
+
+export function wasm_init(): void;