sh-ast 0.3.1 → 0.5.0

package/dist/sh-ast.d.ts

@@ -1,873 +1,3590 @@
 /**
- * Options accepted by {@link parseSync}.
+ * Upstream BinAritOperator constant Add. Its numeric value is preserved exactly.
  *
+ * +
+ *
+ * @public
+ */
+export declare const Add: 81;
+
+/**
+ * Upstream BinAritOperator constant AddAssgn. Its numeric value is preserved exactly.
+ *
+ * +=
+ *
+ * @public
+ */
+export declare const AddAssgn: 49;
+
+/**
+ * Upstream ParExpOperator constant AlternateUnset. Its numeric value is preserved exactly.
+ *
+ * +
+ *
+ * @public
+ */
+export declare const AlternateUnset: 81;
+
+/**
+ * Upstream ParExpOperator constant AlternateUnsetOrNull. Its numeric value is preserved exactly.
+ *
+ * :+
+ *
+ * @public
+ */
+export declare const AlternateUnsetOrNull: 82;
+
+/**
+ * Upstream BinAritOperator constant And. Its numeric value is preserved exactly.
+ *
+ * &
+ *
+ * @public
+ */
+export declare const And: 10;
+
+/**
+ * Upstream BinAritOperator constant AndArit. Its numeric value is preserved exactly.
+ *
+ * &&
+ *
+ * @public
+ */
+export declare const AndArit: 11;
+
+/**
+ * Upstream BinAritOperator constant AndAssgn. Its numeric value is preserved exactly.
+ *
+ * &=
+ *
+ * @public
+ */
+export declare const AndAssgn: 54;
+
+/**
+ * Upstream BinAritOperator constant AndBoolAssgn. Its numeric value is preserved exactly.
+ *
+ * &&=
+ *
+ * @public
+ */
+export declare const AndBoolAssgn: 59;
+
+/**
+ * Upstream BinCmdOperator constant AndStmt. Its numeric value is preserved exactly.
+ *
+ * &&
+ *
+ * @public
+ */
+export declare const AndStmt: 11;
+
+/**
+ * Upstream BinTestOperator constant AndTest. Its numeric value is preserved exactly.
+ *
+ * &&
+ *
+ * @public
+ */
+export declare const AndTest: 11;
+
+/**
+ * Upstream RedirOperator constant AppAll. Its numeric value is preserved exactly.
+ *
+ * &\>\>
+ *
+ * @public
+ */
+export declare const AppAll: 76;
+
+/**
+ * Upstream RedirOperator constant AppAllClob. Its numeric value is preserved exactly.
+ *
+ * &\>\>| with `LangZsh`
+ *
+ * @public
+ */
+export declare const AppAllClob: 77;
+
+/**
+ * Upstream RedirOperator constant AppClob. Its numeric value is preserved exactly.
+ *
+ * \>\>| with `LangZsh`
+ *
+ * @public
+ */
+export declare const AppClob: 70;
+
+/**
+ * Upstream RedirOperator constant AppOut. Its numeric value is preserved exactly.
+ *
+ * \>\>
+ *
+ * @public
+ */
+export declare const AppOut: 64;
+
+/**
+ * ArithmCmd represents an arithmetic command.
+ *
+ * This node will only appear with `LangBash` and `LangMirBSDKorn`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface ArithmCmd {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'ArithmCmd';
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Left: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Right: SyntaxPos;
+    /**
+     * mksh's ((# expr))
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Unsigned: boolean;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    X: ArithmExpr | null;
+}
+
+/**
+ * ArithmExp represents an arithmetic expansion.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface ArithmExp {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'ArithmExp';
+    /**
+     * deprecated $`expr` form
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Bracket: boolean;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Left: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Right: SyntaxPos;
+    /**
+     * mksh's $((# expr))
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Unsigned: boolean;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    X: ArithmExpr | null;
+}
+
+/**
+ * The concrete records and typed nil pointers accepted by upstream syntax.ArithmExpr. Typed nil kinds are limited to this interface's actual implementers; auxiliary records are excluded.
+ *
+ * @public
+ */
+export declare type ArithmExpr =
+| BinaryArithm
+| FlagsArithm
+| ParenArithm
+| UnaryArithm
+| Word
+| TypedNil<'BinaryArithm' | 'FlagsArithm' | 'ParenArithm' | 'UnaryArithm' | 'Word'>;
+
+/**
+ * ArrayElem represents a Bash array element.
+ *
+ * Index can be nil; for example, declare -a x=(value).
+ * Value can be nil; for example, declare -A x=(`index`=).
+ * Finally, neither can be nil; for example, declare -A x=(`index`=value)
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface ArrayElem {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'ArrayElem';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    Comments: Comment_2[] | null;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Index: ArithmExpr | null;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Value: Word | null;
+}
+
+/**
+ * Upstream ParExpOperator constant ArrayExclude. Its numeric value is preserved exactly.
+ *
+ * :| with `LangZsh`
+ *
+ * @public
+ */
+export declare const ArrayExclude: 94;
+
+/**
+ * ArrayExpr represents a Bash array expression.
+ *
+ * This node will only appear with `LangBash`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface ArrayExpr {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'ArrayExpr';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Elems: (ArrayElem | null)[] | null;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    Last: Comment_2[] | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Lparen: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Rparen: SyntaxPos;
+}
+
+/**
+ * Upstream ParExpOperator constant ArrayIntersect. Its numeric value is preserved exactly.
+ *
+ * :* with `LangZsh`
+ *
+ * @public
+ */
+export declare const ArrayIntersect: 95;
+
+/**
+ * Upstream BinAritOperator constant Assgn. Its numeric value is preserved exactly.
+ *
+ * =
+ *
+ * @public
+ */
+export declare const Assgn: 87;
+
+/**
+ * Assign represents an assignment to a variable.
+ *
+ * Here and elsewhere, Index can mean either an index expression into an indexed
+ * array, or a string key into an associative array.
+ *
+ * If Index is non-nil, the value will be a word and not an array as nested
+ * arrays are not allowed.
+ *
+ * If Naked is true and Name is nil, the assignment is part of a `DeclClause` and
+ * the argument (in the Value field) will be evaluated at run-time. This
+ * includes parameter expansions, which may expand to assignments or options.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface Assign {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'Assign';
+    /**
+     * +=
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Append: boolean;
+    /**
+     * =(arr)
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Array: ArrayExpr | null;
+    /**
+     * `i`, ["k"]
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Index: ArithmExpr | null;
+    /**
+     * without '='
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Naked: boolean;
+    /**
+     * must be a valid name
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Name: Lit | null;
+    /**
+     * =val
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Value: Word | null;
+}
+
+/**
+ * Upstream ParExpOperator constant AssignUnset. Its numeric value is preserved exactly.
+ *
+ * =
+ *
+ * @public
+ */
+export declare const AssignUnset: 87;
+
+/**
+ * Upstream ParExpOperator constant AssignUnsetOrNull. Its numeric value is preserved exactly.
+ *
+ * :=
+ *
+ * @public
+ */
+export declare const AssignUnsetOrNull: 88;
+
+/**
+ * The upstream BinAritOperator domain: exact named tokens, the Go zero value, and explicitly validated unnamed uint32 values. Constants shared by upstream families retain their shared numeric identity.
+ *
+ * @public
+ */
+export declare type BinAritOperator =
+| 0
+| typeof Add
+| typeof AddAssgn
+| typeof And
+| typeof AndArit
+| typeof AndAssgn
+| typeof AndBoolAssgn
+| typeof Assgn
+| typeof Comma
+| typeof Eql
+| typeof Geq
+| typeof Gtr
+| typeof Leq
+| typeof Lss
+| typeof Mul
+| typeof MulAssgn
+| typeof Neq
+| typeof Or
+| typeof OrArit
+| typeof OrAssgn
+| typeof OrBoolAssgn
+| typeof Pow
+| typeof PowAssgn
+| typeof Quo
+| typeof QuoAssgn
+| typeof Rem
+| typeof RemAssgn
+| typeof Shl
+| typeof ShlAssgn
+| typeof Shr
+| typeof ShrAssgn
+| typeof Sub
+| typeof SubAssgn
+| typeof TernColon
+| typeof TernQuest
+| typeof Xor
+| typeof XorAssgn
+| typeof XorBool
+| typeof XorBoolAssgn
+| RawOperator<'BinAritOperator'>;
+
+/**
+ * BinaryArithm represents a binary arithmetic expression.
+ *
+ * If Op is any assign operator, X will be a word with a single `Lit` whose value
+ * is a valid name.
+ *
+ * Ternary operators like "a ? b : c" are fit into this structure. Thus, if
+ * Op==`TernQuest`, Y will be a `BinaryArithm` with Op==`TernColon`.
+ * `TernColon` does not appear in any other scenario.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface BinaryArithm {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'BinaryArithm';
+    /**
+     * Upstream operator value, preserving named tokens, zero, and explicitly represented raw uint32 values.
+     */
+    Op: BinAritOperator;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    OpPos: SyntaxPos;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    X: ArithmExpr | null;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Y: ArithmExpr | null;
+}
+
+/**
+ * BinaryCmd represents a binary expression between two statements.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface BinaryCmd {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'BinaryCmd';
+    /**
+     * Upstream operator value, preserving named tokens, zero, and explicitly represented raw uint32 values.
+     */
+    Op: BinCmdOperator;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    OpPos: SyntaxPos;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    X: Stmt | null;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Y: Stmt | null;
+}
+
+/**
+ * BinaryTest represents a binary test expression.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface BinaryTest {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'BinaryTest';
+    /**
+     * Upstream operator value, preserving named tokens, zero, and explicitly represented raw uint32 values.
+     */
+    Op: BinTestOperator;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    OpPos: SyntaxPos;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    X: TestExpr | null;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Y: TestExpr | null;
+}
+
+/**
+ * The upstream BinCmdOperator domain: exact named tokens, the Go zero value, and explicitly validated unnamed uint32 values. Constants shared by upstream families retain their shared numeric identity.
+ *
+ * @public
+ */
+export declare type BinCmdOperator =
+0 | typeof AndStmt | typeof OrStmt | typeof Pipe | typeof PipeAll | RawOperator<'BinCmdOperator'>;
+
+/**
+ * The upstream BinTestOperator domain: exact named tokens, the Go zero value, and explicitly validated unnamed uint32 values. Constants shared by upstream families retain their shared numeric identity.
+ *
+ * @public
+ */
+export declare type BinTestOperator =
+| 0
+| typeof AndTest
+| typeof OrTest
+| typeof TsAfter
+| typeof TsBefore
+| typeof TsDevIno
+| typeof TsEql
+| typeof TsGeq
+| typeof TsGtr
+| typeof TsLeq
+| typeof TsLss
+| typeof TsMatch
+| typeof TsMatchShort
+| typeof TsNeq
+| typeof TsNewer
+| typeof TsNoMatch
+| typeof TsOlder
+| typeof TsReMatch
+| RawOperator<'BinTestOperator'>;
+
+/**
+ * Upstream UnAritOperator constant BitNegation. Its numeric value is preserved exactly.
+ *
+ * ~
+ *
+ * @public
+ */
+export declare const BitNegation: 40;
+
+/**
+ * Block represents a series of commands that should be executed in a nested
+ * scope. It is essentially a list of statements within curly braces.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface Block {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'Block';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    Last: Comment_2[] | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Lbrace: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Rbrace: SyntaxPos;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Stmts: (Stmt | null)[] | null;
+}
+
+/**
+ * BraceExp represents a Bash brace expression, such as "\{a,f\}" or "\{1..10\}".
+ *
+ * This node will only appear as a result of `SplitBraces`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface BraceExp {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'BraceExp';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Elems: (Word | null)[] | null;
+    /**
+     * \{x..y[..incr]\} instead of \{x,y[,...]\}
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Sequence: boolean;
+}
+
+/**
+ * Upstream CaseOperator constant Break. Its numeric value is preserved exactly.
+ *
+ * ;;
+ *
+ * @public
+ */
+export declare const Break: 35;
+
+/**
+ * CallExpr represents a command execution or function call, otherwise known as
+ * a "simple command".
+ *
+ * If Args is empty, Assigns apply to the shell environment. Otherwise, they are
+ * variables that cannot be arrays and which only apply to the call.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface CallExpr {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'CallExpr';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Args: (Word | null)[] | null;
+    /**
+     * a=x b=y args
+     *
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Assigns: (Assign | null)[] | null;
+}
+
+/**
+ * CaseClause represents a case (switch) clause.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface CaseClause {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'CaseClause';
+    /**
+     * deprecated mksh form with braces instead of in/esac
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Braces: boolean;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Case: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Esac: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    In: SyntaxPos;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Items: (CaseItem | null)[] | null;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    Last: Comment_2[] | null;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Word: Word | null;
+}
+
+/**
+ * CaseItem represents a pattern list (case) within a `CaseClause`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface CaseItem {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'CaseItem';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    Comments: Comment_2[] | null;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    Last: Comment_2[] | null;
+    /**
+     * Upstream operator value, preserving named tokens, zero, and explicitly represented raw uint32 values.
+     */
+    Op: CaseOperator;
+    /**
+     * unset if it was finished by "esac"
+     *
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    OpPos: SyntaxPos;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Patterns: (Word | null)[] | null;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Stmts: (Stmt | null)[] | null;
+}
+
+/**
+ * The upstream CaseOperator domain: exact named tokens, the Go zero value, and explicitly validated unnamed uint32 values. Constants shared by upstream families retain their shared numeric identity.
+ *
+ * @public
+ */
+export declare type CaseOperator =
+| 0
+| typeof Break
+| typeof Fallthrough
+| typeof Resume
+| typeof ResumeKorn
+| RawOperator<'CaseOperator'>;
+
+/**
+ * Upstream RedirOperator constant ClbOut. Its numeric value is preserved exactly.
+ *
+ * Deprecated: use `RdrClob`
+ *
+ * @public
+ */
+export declare const ClbOut: 69;
+
+/**
+ * Upstream ProcOperator constant CmdIn. Its numeric value is preserved exactly.
+ *
+ * \<(
+ *
+ * @public
+ */
+export declare const CmdIn: 78;
+
+/**
+ * Upstream ProcOperator constant CmdInTemp. Its numeric value is preserved exactly.
+ *
+ * =(
+ *
+ * @public
+ */
+export declare const CmdInTemp: 79;
+
+/**
+ * Upstream ProcOperator constant CmdOut. Its numeric value is preserved exactly.
+ *
+ * \>(
+ *
+ * @public
+ */
+export declare const CmdOut: 80;
+
+/**
+ * CmdSubst represents a command substitution.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface CmdSubst {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'CmdSubst';
+    /**
+     * deprecated `foo`
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Backquotes: boolean;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    Last: Comment_2[] | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Left: SyntaxPos;
+    /**
+     * mksh's $\{|foo;\}
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    ReplyVar: boolean;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Right: SyntaxPos;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Stmts: (Stmt | null)[] | null;
+    /**
+     * mksh's $\{ foo;\}
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    TempFile: boolean;
+}
+
+/**
+ * Upstream BinAritOperator constant Comma. Its numeric value is preserved exactly.
+ *
+ * ,
+ *
+ * @public
+ */
+export declare const Comma: 98;
+
+/**
+ * The concrete records and typed nil pointers accepted by upstream syntax.Command. Typed nil kinds are limited to this interface's actual implementers; auxiliary records are excluded.
+ *
+ * @public
+ */
+export declare type Command =
+| ArithmCmd
+| BinaryCmd
+| Block
+| CallExpr
+| CaseClause
+| CoprocClause
+| DeclClause
+| ForClause
+| FuncDecl
+| IfClause
+| LetClause
+| Subshell
+| TestClause
+| TestDecl
+| TimeClause
+| WhileClause
+| TypedNil<
+| 'ArithmCmd'
+| 'BinaryCmd'
+| 'Block'
+| 'CallExpr'
+| 'CaseClause'
+| 'CoprocClause'
+| 'DeclClause'
+| 'ForClause'
+| 'FuncDecl'
+| 'IfClause'
+| 'LetClause'
+| 'Subshell'
+| 'TestClause'
+| 'TestDecl'
+| 'TimeClause'
+| 'WhileClause'
+>;
+
+/**
+ * Comment represents a single comment on a single line.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+declare interface Comment_2 {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'Comment';
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Hash: SyntaxPos;
+    /**
+     * Upstream string bytes; non-UTF-8 values remain bytes rather than replacement text.
+     */
+    Text: GoString;
+}
+export { Comment_2 as Comment }
+
+/**
+ * CoprocClause represents a Bash coproc clause.
+ *
+ * This node will only appear with `LangBash`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface CoprocClause {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'CoprocClause';
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Coproc: SyntaxPos;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Name: Word | null;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Stmt: Stmt | null;
+}
+
+/**
+ * CStyleLoop represents the behavior of a for clause similar to the C
+ * language.
+ *
+ * This node will only appear with `LangBash`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface CStyleLoop {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'CStyleLoop';
+    /**
+     * Init, Cond, Post can each be nil, if the for loop construct omits it.
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Cond: ArithmExpr | null;
+    /**
+     * Init, Cond, Post can each be nil, if the for loop construct omits it.
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Init: ArithmExpr | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Lparen: SyntaxPos;
+    /**
+     * Init, Cond, Post can each be nil, if the for loop construct omits it.
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Post: ArithmExpr | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Rparen: SyntaxPos;
+}
+
+/**
+ * Upstream RedirOperator constant DashHdoc. Its numeric value is preserved exactly.
+ *
+ * \<\<-
+ *
+ * @public
+ */
+export declare const DashHdoc: 72;
+
+/**
+ * DblQuoted represents a list of nodes within double quotes.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface DblQuoted {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'DblQuoted';
+    /**
+     * $""
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Dollar: boolean;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Left: SyntaxPos;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Parts: (WordPart | null)[] | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Right: SyntaxPos;
+}
+
+/**
+ * Upstream UnAritOperator constant Dec. Its numeric value is preserved exactly.
+ *
+ * --
+ *
+ * @public
+ */
+export declare const Dec: 42;
+
+/**
+ * DeclClause represents a Bash declare clause.
+ *
+ * Args can contain a mix of regular and naked assignments. The naked
+ * assignments can represent either options or variable names.
+ *
+ * This node will only appear with `LangBash`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface DeclClause {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'DeclClause';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Args: (Assign | null)[] | null;
+    /**
+     * Variant is one of "declare", "local", "export", "readonly",
+     * "typeset", or "nameref".
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Variant: Lit | null;
+}
+
+/**
+ * Upstream ParExpOperator constant DefaultUnset. Its numeric value is preserved exactly.
+ *
+ * -
+ *
+ * @public
+ */
+export declare const DefaultUnset: 83;
+
+/**
+ * Upstream ParExpOperator constant DefaultUnsetOrNull. Its numeric value is preserved exactly.
+ *
+ * :-
+ *
+ * @public
+ */
+export declare const DefaultUnsetOrNull: 84;
+
+/**
+ * Upstream RedirOperator constant DplIn. Its numeric value is preserved exactly.
+ *
+ * \<&
+ *
+ * @public
+ */
+export declare const DplIn: 67;
+
+/**
+ * Upstream RedirOperator constant DplOut. Its numeric value is preserved exactly.
+ *
+ * \>&
+ *
+ * @public
+ */
+export declare const DplOut: 68;
+
+/**
+ * Upstream BinAritOperator constant Eql. Its numeric value is preserved exactly.
+ *
+ * ==
+ *
+ * @public
+ */
+export declare const Eql: 45;
+
+/**
+ * Upstream ParExpOperator constant ErrorUnset. Its numeric value is preserved exactly.
+ *
+ * ?
+ *
+ * @public
+ */
+export declare const ErrorUnset: 85;
+
+/**
+ * Upstream ParExpOperator constant ErrorUnsetOrNull. Its numeric value is preserved exactly.
+ *
+ * :?
+ *
+ * @public
+ */
+export declare const ErrorUnsetOrNull: 86;
+
+/**
+ * Expansion represents string manipulation in a `ParamExp` other than those
+ * covered by `Replace`.
+ *
+ * Auxiliary syntax data, not a syntax.Node; it has no independent source bounds.
+ *
+ * @public
+ */
+export declare interface Expansion {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'Expansion';
+    /**
+     * Upstream operator value, preserving named tokens, zero, and explicitly represented raw uint32 values.
+     */
+    Op: ParExpOperator;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Word: Word | null;
+}
+
+/**
+ * ExtGlob represents a Bash extended globbing expression. Note that these are
+ * parsed independently of whether or not `shopt -s extglob` has been used,
+ * as the parser runs statically and independently of any interpreter.
+ *
+ * This node will only appear with `LangBash` and `LangMirBSDKorn`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface ExtGlob {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'ExtGlob';
+    /**
+     * Upstream operator value, preserving named tokens, zero, and explicitly represented raw uint32 values.
+     */
+    Op: GlobOperator;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    OpPos: SyntaxPos;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Pattern: Lit | null;
+}
+
+/**
+ * Upstream CaseOperator constant Fallthrough. Its numeric value is preserved exactly.
+ *
+ * ;&
+ *
+ * @public
+ */
+export declare const Fallthrough: 36;
+
+/**
+ * File represents a shell source file.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+declare interface File_2 {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'File';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    Last: Comment_2[] | null;
+    /**
+     * Upstream string bytes; non-UTF-8 values remain bytes rather than replacement text.
+     */
+    Name: GoString;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Stmts: (Stmt | null)[] | null;
+}
+export { File_2 as File }
+
+/**
+ * FlagsArithm represents zsh subscript flags attached to an arithmetic expression,
+ * such as $\{array[(flags)expr]\}.
+ *
+ * This node will only appear with `LangZsh`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface FlagsArithm {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'FlagsArithm';
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Flags: Lit | null;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    X: ArithmExpr | null;
+}
+
+/**
+ * ForClause represents a for or a select clause. The latter is only present in
+ * Bash.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface ForClause {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'ForClause';
+    /**
+     * deprecated form with \{ \} instead of do/done
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Braces: boolean;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Do: (Stmt | null)[] | null;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    DoLast: Comment_2[] | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    DoPos: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    DonePos: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    ForPos: SyntaxPos;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Loop: Loop | null;
+    /**
+     * False is an explicit upstream value and is never omitted.
+     */
+    Select: boolean;
+}
+
+/**
+ * FuncDecl represents the declaration of a function.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface FuncDecl {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'FuncDecl';
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Body: Stmt | null;
+    /**
+     * Only one of these is set at a time.
+     * Neither is set when declaring an anonymous func with `LangZsh`.
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Name: Lit | null;
+    /**
+     * When declaring many func names with `LangZsh`.
+     *
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Names: (Lit | null)[] | null;
+    /**
+     * with () parentheses, can only be false when RsrvWord==true
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Parens: boolean;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Position: SyntaxPos;
+    /**
+     * non-posix "function f" style
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    RsrvWord: boolean;
+}
+
+/**
+ * Upstream BinAritOperator constant Geq. Its numeric value is preserved exactly.
+ *
+ * \>=
+ *
+ * @public
+ */
+export declare const Geq: 48;
+
+/**
+ * Upstream GlobOperator constant GlobExcept. Its numeric value is preserved exactly.
+ *
+ * !(
+ *
+ * @public
+ */
+export declare const GlobExcept: 143;
+
+/**
+ * Upstream GlobOperator constant GlobOne. Its numeric value is preserved exactly.
+ *
+ * \@(
+ *
+ * @public
+ */
+export declare const GlobOne: 142;
+
+/**
+ * Upstream GlobOperator constant GlobOneOrMore. Its numeric value is preserved exactly.
+ *
+ * +(
+ *
+ * @public
+ */
+export declare const GlobOneOrMore: 141;
+
+/**
+ * The upstream GlobOperator domain: exact named tokens, the Go zero value, and explicitly validated unnamed uint32 values. Constants shared by upstream families retain their shared numeric identity.
+ *
+ * @public
+ */
+export declare type GlobOperator =
+| 0
+| typeof GlobExcept
+| typeof GlobOne
+| typeof GlobOneOrMore
+| typeof GlobZeroOrMore
+| typeof GlobZeroOrOne
+| RawOperator<'GlobOperator'>;
+
+/**
+ * Upstream GlobOperator constant GlobZeroOrMore. Its numeric value is preserved exactly.
+ *
+ * *(
+ *
+ * @public
+ */
+export declare const GlobZeroOrMore: 140;
+
+/**
+ * Upstream GlobOperator constant GlobZeroOrOne. Its numeric value is preserved exactly.
+ *
+ * ?(
+ *
+ * @public
+ */
+export declare const GlobZeroOrOne: 139;
+
+/**
+ * A Go string's exact bytes. Valid UTF-8 is represented as a JavaScript string; other bytes use Uint8Array. String inputs must not contain unpaired surrogates, which have no faithful UTF-8 representation.
+ *
+ * @public
+ */
+export declare type GoString = string | Uint8Array;
+
+/**
+ * Upstream BinAritOperator constant Gtr. Its numeric value is preserved exactly.
+ *
+ * \>
+ *
+ * @public
+ */
+export declare const Gtr: 63;
+
+/**
+ * Upstream RedirOperator constant Hdoc. Its numeric value is preserved exactly.
+ *
+ * \<\<
+ *
+ * @public
+ */
+export declare const Hdoc: 71;
+
+/**
+ * IfClause represents an if statement.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface IfClause {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'IfClause';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Cond: (Stmt | null)[] | null;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    CondLast: Comment_2[] | null;
+    /**
+     * if non-nil, an "elif" or an "else"
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Else: IfClause | null;
+    /**
+     * position of "fi", shared with .Else if non-nil
+     *
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    FiPos: SyntaxPos;
+    /**
+     * comments on the first "elif", "else", or "fi"
+     *
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    Last: Comment_2[] | null;
+    /**
+     * position of the starting "if", "elif", or "else" token
+     *
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Position: SyntaxPos;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Then: (Stmt | null)[] | null;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    ThenLast: Comment_2[] | null;
+    /**
+     * position of "then", empty if this is an "else"
+     *
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    ThenPos: SyntaxPos;
+}
+
+/**
+ * Upstream UnAritOperator constant Inc. Its numeric value is preserved exactly.
+ *
+ * ++
+ *
+ * @public
+ */
+export declare const Inc: 41;
+
+/**
+ * An argument cannot be represented by the binding or violates an upstream
+ * operation's input constraint. It is distinct from malformed shell source.
+ * @public
+ */
+export declare class InputError extends ShAstError {
+    readonly Message: GoString;
+    /** Identifies caller input that cannot be passed faithfully to the operation. */
+    readonly code = "SH_AST_SYNTAX_INPUT";
+    /** Retains exact upstream message bytes even when Error.message needs text. */
+    constructor(Message: GoString);
+}
+
+/**
+ * Upstream LangVariant constant LangAuto. Its numeric value is preserved exactly.
+ *
+ * LangAuto corresponds to automatic language detection,
+ * commonly used by end-user applications like shfmt,
+ * which can guess a file's language variant given its filename or shebang.
+ *
+ * At this time, `Variant` does not support LangAuto.
+ *
+ * @public
+ */
+export declare const LangAuto: 32;
+
+/**
+ * Upstream LangVariant constant LangBash. Its numeric value is preserved exactly.
+ *
+ * LangBash corresponds to the GNU Bash language, as described in its
+ * manual at https://www.gnu.org/software/bash/manual/bash.html.
+ *
+ * We currently follow Bash version 5.2.
+ *
+ * Its string representation is "bash".
+ *
+ * @public
+ */
+export declare const LangBash: 1;
+
+/**
+ * Upstream LangVariant constant LangBats. Its numeric value is preserved exactly.
+ *
+ * LangBats corresponds to the Bash Automated Testing System language,
+ * as described at https://github.com/bats-core/bats-core. Note that
+ * it's just a small extension of the Bash language.
+ *
+ * Its string representation is "bats".
+ *
+ * @public
+ */
+export declare const LangBats: 8;
+
+/**
+ * A syntax feature rejected for the selected upstream language variant.
+ * @public
+ */
+export declare class LangError extends ShAstError {
+    readonly Message: GoString;
+    readonly Filename: GoString;
+    readonly Pos: SyntaxPos;
+    readonly Feature: GoString;
+    readonly Langs: readonly number[];
+    readonly LangUsed: number;
+    readonly File: File_2 | null;
+    /** Identifies a dialect-specific syntax failure. */
+    readonly code = "SH_AST_SYNTAX_LANG";
+    /** Preserves the feature, permitted variants, actual variant and partial tree. */
+    constructor(Message: GoString, Filename: GoString, Pos: SyntaxPos, Feature: GoString, Langs: readonly number[], LangUsed: number, File: File_2 | null);
+}
+
+/**
+ * Upstream LangVariant constant LangMirBSDKorn. Its numeric value is preserved exactly.
+ *
+ * LangMirBSDKorn corresponds to the MirBSD Korn Shell, also known as
+ * mksh, as described at http://www.mirbsd.org/htman/i386/man1/mksh.htm.
+ * Note that it shares some features with Bash, due to the shared
+ * ancestry that is ksh.
+ *
+ * We currently follow mksh version 59.
+ *
+ * Its string representation is "mksh".
+ *
+ * @public
+ */
+export declare const LangMirBSDKorn: 4;
+
+/**
+ * Upstream LangVariant constant LangPOSIX. Its numeric value is preserved exactly.
+ *
+ * LangPOSIX corresponds to the POSIX Shell language, as described at
+ * https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html.
+ *
+ * Its string representation is "posix" or "sh".
+ *
+ * @public
+ */
+export declare const LangPOSIX: 2;
+
+/**
+ * Known upstream language variant values, including legacy zero and LangAuto. Each operation retains its own constraints: the parser Variant option rejects LangAuto even though the language-value type includes it.
+ *
+ * @public
+ */
+export declare type LangVariant =
+| 0
+| typeof LangAuto
+| typeof LangBash
+| typeof LangBats
+| typeof LangMirBSDKorn
+| typeof LangPOSIX
+| typeof LangZsh;
+
+/**
+ * Upstream LangVariant constant LangZsh. Its numeric value is preserved exactly.
+ *
+ * LangZsh corresponds to the Z shell, as described at https://www.zsh.org/.
+ *
+ * Note that its support in the syntax package is experimental and
+ * incomplete for now. See https://github.com/mvdan/sh/issues/120.
+ *
+ * We currently follow Zsh version 5.9.
+ *
+ * Its string representation is "zsh".
+ *
+ * @public
+ */
+export declare const LangZsh: 16;
+
+/**
+ * Upstream BinAritOperator constant Leq. Its numeric value is preserved exactly.
+ *
+ * \<=
+ *
+ * @public
+ */
+export declare const Leq: 47;
+
+/**
+ * LetClause represents a Bash let clause.
+ *
+ * This node will only appear with `LangBash` and `LangMirBSDKorn`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface LetClause {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'LetClause';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Exprs: (ArithmExpr | null)[] | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Let: SyntaxPos;
+}
+
+/**
+ * Lit represents a string literal.
+ *
+ * Note that a parsed string literal may not appear as-is in the original source
+ * code, as it is possible to split literals by escaping newlines. The splitting
+ * is lost, but the end position is not.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface Lit {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'Lit';
+    /**
+     * Upstream string bytes; non-UTF-8 values remain bytes rather than replacement text.
+     */
+    Value: GoString;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    ValueEnd: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    ValuePos: SyntaxPos;
+}
+
+/**
+ * The concrete records and typed nil pointers accepted by upstream syntax.Loop. Typed nil kinds are limited to this interface's actual implementers; auxiliary records are excluded.
+ *
+ * @public
+ */
+export declare type Loop = CStyleLoop | WordIter | TypedNil<'CStyleLoop' | 'WordIter'>;
+
+/**
+ * Upstream ParExpOperator constant LowerAll. Its numeric value is preserved exactly.
+ *
+ * ,,
+ *
+ * @public
+ */
+export declare const LowerAll: 99;
+
+/**
+ * Upstream ParExpOperator constant LowerFirst. Its numeric value is preserved exactly.
+ *
+ * ,
+ *
+ * @public
+ */
+export declare const LowerFirst: 98;
+
+/**
+ * Upstream BinAritOperator constant Lss. Its numeric value is preserved exactly.
+ *
+ * \<
+ *
+ * @public
+ */
+export declare const Lss: 65;
+
+/**
+ * Upstream ParExpOperator constant MatchEmpty. Its numeric value is preserved exactly.
+ *
+ * :# with `LangZsh`
+ *
+ * @public
+ */
+export declare const MatchEmpty: 93;
+
+/**
+ * Upstream UnAritOperator constant Minus. Its numeric value is preserved exactly.
+ *
+ * -
+ *
+ * @public
+ */
+export declare const Minus: 83;
+
+/**
+ * Upstream BinAritOperator constant Mul. Its numeric value is preserved exactly.
+ *
+ * *
+ *
+ * @public
+ */
+export declare const Mul: 43;
+
+/**
+ * Upstream BinAritOperator constant MulAssgn. Its numeric value is preserved exactly.
+ *
+ * *=
+ *
+ * @public
+ */
+export declare const MulAssgn: 51;
+
+/**
+ * Upstream ParNamesOperator constant NamesPrefix. Its numeric value is preserved exactly.
+ *
+ * *
+ *
+ * @public
+ */
+export declare const NamesPrefix: 43;
+
+/**
+ * Upstream ParNamesOperator constant NamesPrefixWords. Its numeric value is preserved exactly.
+ *
+ * \@
+ *
+ * @public
+ */
+export declare const NamesPrefixWords: 100;
+
+/**
+ * Upstream BinAritOperator constant Neq. Its numeric value is preserved exactly.
+ *
+ * !=
+ *
+ * @public
+ */
+export declare const Neq: 46;
+
+/**
+ * Constructs an upstream position. uint64 arguments use bigint when outside the
+ * safe-number range; upstream clamps offsets and zeroes overflowing line/column
+ * values. The binding does not replace those rules with its own range policy.
+ * @public
+ */
+export declare function newPos(offset: number | bigint, line: number | bigint, column: number | bigint): SyntaxPos;
+
+/**
+ * The concrete records and typed nil pointers accepted by upstream syntax.Node. Typed nil kinds are limited to this interface's actual implementers; auxiliary records are excluded.
+ *
+ * @public
+ */
+declare type Node_2 =
+| ArithmCmd
+| ArithmExp
+| ArrayElem
+| ArrayExpr
+| Assign
+| BinaryArithm
+| BinaryCmd
+| BinaryTest
+| Block
+| BraceExp
+| CStyleLoop
+| CallExpr
+| CaseClause
+| CaseItem
+| CmdSubst
+| Comment_2
+| CoprocClause
+| DblQuoted
+| DeclClause
+| ExtGlob
+| File_2
+| FlagsArithm
+| ForClause
+| FuncDecl
+| IfClause
+| LetClause
+| Lit
+| ParamExp
+| ParenArithm
+| ParenTest
+| ProcSubst
+| Redirect
+| SglQuoted
+| Stmt
+| Subshell
+| TestClause
+| TestDecl
+| TimeClause
+| UnaryArithm
+| UnaryTest
+| WhileClause
+| Word
+| WordIter
+| TypedNil<
+| 'ArithmCmd'
+| 'ArithmExp'
+| 'ArrayElem'
+| 'ArrayExpr'
+| 'Assign'
+| 'BinaryArithm'
+| 'BinaryCmd'
+| 'BinaryTest'
+| 'Block'
+| 'BraceExp'
+| 'CStyleLoop'
+| 'CallExpr'
+| 'CaseClause'
+| 'CaseItem'
+| 'CmdSubst'
+| 'Comment'
+| 'CoprocClause'
+| 'DblQuoted'
+| 'DeclClause'
+| 'ExtGlob'
+| 'File'
+| 'FlagsArithm'
+| 'ForClause'
+| 'FuncDecl'
+| 'IfClause'
+| 'LetClause'
+| 'Lit'
+| 'ParamExp'
+| 'ParenArithm'
+| 'ParenTest'
+| 'ProcSubst'
+| 'Redirect'
+| 'SglQuoted'
+| 'Stmt'
+| 'Subshell'
+| 'TestClause'
+| 'TestDecl'
+| 'TimeClause'
+| 'UnaryArithm'
+| 'UnaryTest'
+| 'WhileClause'
+| 'Word'
+| 'WordIter'
+>;
+export { Node_2 as Node }
+
+/**
+ * Computes a node's ending position using upstream's End method, including
+ * recovered/invalid behavior and changes to text or child nodes.
+ * @public
+ */
+export declare function nodeEnd(node: Node_2): SyntaxPos;
+
+/**
+ * Computes a node's starting position from its current fields using upstream's
+ * Pos method. No cached parse-time position can override subsequent tree edits.
+ * @public
+ */
+export declare function nodePos(node: Node_2): SyntaxPos;
+
+/**
+ * A node's upstream bounds as observed during parsing. These values refer to the
+ * original source, even when the corresponding syntax record is later edited.
+ * @public
+ */
+export declare interface NodePositions {
+    /** Starting byte position observed for the original parsed node. */
+    readonly Pos: Readonly<SyntaxPos>;
+    /** Exclusive ending byte position observed for the original parsed node. */
+    readonly End: Readonly<SyntaxPos>;
+}
+
+/**
+ * Upstream UnAritOperator constant Not. Its numeric value is preserved exactly.
+ *
+ * !
+ *
+ * @public
+ */
+export declare const Not: 39;
+
+/**
+ * The upstream uint32 operator families. A family name identifies the Go named type, not the spelling of one token.
+ *
+ * @public
+ */
+export declare type OperatorFamily =
+| 'BinAritOperator'
+| 'BinCmdOperator'
+| 'BinTestOperator'
+| 'CaseOperator'
+| 'GlobOperator'
+| 'ParExpOperator'
+| 'ParNamesOperator'
+| 'ProcOperator'
+| 'RedirOperator'
+| 'UnAritOperator'
+| 'UnTestOperator';
+
+/**
+ * Upstream BinAritOperator constant Or. Its numeric value is preserved exactly.
+ *
+ * |
+ *
+ * @public
+ */
+export declare const Or: 13;
+
+/**
+ * Upstream BinAritOperator constant OrArit. Its numeric value is preserved exactly.
+ *
+ * ||
+ *
+ * @public
+ */
+export declare const OrArit: 12;
+
+/**
+ * Upstream BinAritOperator constant OrAssgn. Its numeric value is preserved exactly.
+ *
+ * |=
+ *
+ * @public
+ */
+export declare const OrAssgn: 55;
+
+/**
+ * Upstream BinAritOperator constant OrBoolAssgn. Its numeric value is preserved exactly.
+ *
+ * ||=
+ *
+ * @public
+ */
+export declare const OrBoolAssgn: 60;
+
+/**
+ * Upstream BinCmdOperator constant OrStmt. Its numeric value is preserved exactly.
+ *
+ * ||
+ *
+ * @public
+ */
+export declare const OrStmt: 12;
+
+/**
+ * Upstream BinTestOperator constant OrTest. Its numeric value is preserved exactly.
+ *
+ * ||
+ *
+ * @public
+ */
+export declare const OrTest: 12;
+
+/**
+ * Upstream ParExpOperator constant OtherParamOps. Its numeric value is preserved exactly.
+ *
+ * \@
+ *
+ * @public
+ */
+export declare const OtherParamOps: 100;
+
+/**
+ * ParamExp represents a parameter expansion.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface ParamExp {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'ParamExp';
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Dollar: SyntaxPos;
+    /**
+     * Only one of these is set at a time.
+     * given how we've grown the number of booleans
+     * $\{!a\}
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Excl: boolean;
+    /**
+     * $\{a:-b\}, $\{a#b\}, etc
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Exp: Expansion | null;
+    /**
+     * $\{(flags)a\} with `LangZsh`
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Flags: Lit | null;
+    /**
+     * $\{a`i`\}, $\{a["k"]\}, or a $\{a[i,j]\} slice with `LangZsh`
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Index: ArithmExpr | null;
+    /**
+     * $\{+a\} with `LangZsh`
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    IsSet: boolean;
+    /**
+     * $\{#a\}
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Length: boolean;
+    /**
+     * Only one of these is set at a time.
+     * because it should be impossible for multiple to be set at once,
+     * and a flat structure like this takes up more space.
+     * $\{a:h2\} with `LangZsh`
+     *
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Modifiers: (Lit | null)[] | null;
+    /**
+     * $\{!prefix*\} or $\{!prefix\@\}
+     *
+     * Upstream operator value, preserving named tokens, zero, and explicitly represented raw uint32 values.
+     */
+    Names: ParNamesOperator;
+    /**
+     * A nested parameter expression in the form of `ParamExp` or `CmdSubst`,
+     * or either of those in a `DblQuoted`. Only possible with `LangZsh`.
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    NestedParam: WordPart | null;
+    /**
+     * Only one of these is set at a time,
+     * or neither with `LangZsh` when the name is omitted.
+     * even if that would be mildly annoying to non-Zsh users.
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Param: Lit | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Rbrace: SyntaxPos;
+    /**
+     * $\{a/x/y\}
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Repl: Replace | null;
+    /**
+     * $a instead of $\{a\}
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Short: boolean;
+    /**
+     * $\{a:x:y\}
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Slice: Slice | null;
+    /**
+     * mksh's $\{%a\}
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Width: boolean;
+}
+
+/**
+ * ParenArithm represents an arithmetic expression within parentheses.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface ParenArithm {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'ParenArithm';
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Lparen: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Rparen: SyntaxPos;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    X: ArithmExpr | null;
+}
+
+/**
+ * ParenTest represents a test expression within parentheses.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface ParenTest {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'ParenTest';
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Lparen: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Rparen: SyntaxPos;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    X: TestExpr | null;
+}
+
+/**
+ * The upstream ParExpOperator domain: exact named tokens, the Go zero value, and explicitly validated unnamed uint32 values. Constants shared by upstream families retain their shared numeric identity.
+ *
+ * @public
+ */
+export declare type ParExpOperator =
+| 0
+| typeof AlternateUnset
+| typeof AlternateUnsetOrNull
+| typeof ArrayExclude
+| typeof ArrayIntersect
+| typeof AssignUnset
+| typeof AssignUnsetOrNull
+| typeof DefaultUnset
+| typeof DefaultUnsetOrNull
+| typeof ErrorUnset
+| typeof ErrorUnsetOrNull
+| typeof LowerAll
+| typeof LowerFirst
+| typeof MatchEmpty
+| typeof OtherParamOps
+| typeof RemLargePrefix
+| typeof RemLargeSuffix
+| typeof RemSmallPrefix
+| typeof RemSmallSuffix
+| typeof UpperAll
+| typeof UpperFirst
+| RawOperator<'ParExpOperator'>;
+
+/**
+ * The upstream ParNamesOperator domain: exact named tokens, the Go zero value, and explicitly validated unnamed uint32 values. Constants shared by upstream families retain their shared numeric identity.
+ *
+ * @public
+ */
+export declare type ParNamesOperator =
+0 | typeof NamesPrefix | typeof NamesPrefixWords | RawOperator<'ParNamesOperator'>;
+
+/**
+ * Mutable upstream syntax together with a separate source-bound position view.
+ * Editing File never updates Positions; source consumers can retain original
+ * spans while transformations query live nodePos/nodeEnd as needed.
+ * @public
+ */
+export declare interface ParsedFile {
+    /** The complete mutable upstream File; no bounds or consumer fields are added. */
+    readonly File: File_2;
+    /** Immutable original observations, keyed by this File's node identities. */
+    readonly Positions: PositionSnapshot;
+}
+
+/**
+ * A source grammar error reported by mvdan/sh, with the partial parsed file.
+ * @public
+ */
+export declare class ParseError extends ShAstError {
+    readonly Message: GoString;
+    readonly Filename: GoString;
+    readonly Pos: SyntaxPos;
+    readonly Text: GoString;
+    readonly Incomplete: boolean;
+    readonly File: File_2 | null;
+    /** Identifies a source grammar failure independently of its display text. */
+    readonly code = "SH_AST_SYNTAX_PARSE";
+    /**
+     * Keeps the original Go fields. Message is the formatted upstream error;
+     * Text is its unformatted diagnostic, and File is the result returned with it.
+     */
+    constructor(Message: GoString, Filename: GoString, Pos: SyntaxPos, Text: GoString, Incomplete: boolean, File: File_2 | null);
+}
+
+/**
+ * Whole-file parser inputs corresponding to upstream controls. Defaults match
+ * NewParser; in particular comments are retained only when KeepComments is true.
+ * Numeric int arguments accept bigint because Go's WASM int is signed 64-bit.
+ * @public
+ */
+export declare interface ParseOptions {
+    /** Source identity carried by File/errors; no file is opened by the binding. */
+    Filename?: GoString;
+    /** Retains comment nodes when true; upstream defaults to false. */
+    KeepComments?: boolean;
+    /** Upstream LangVariant value. Variant rejects unsupported values, including LangAuto. */
+    Variant?: number | bigint;
+    /** Lexer delimiter with upstream byte-length, whitespace and prefix semantics. */
+    StopAt?: GoString;
+    /** Maximum number of recoverable missing grammar tokens, using upstream behavior. */
+    RecoverErrors?: number | bigint;
+}
+
+/**
+ * Parses exact source bytes, or well-formed Unicode text encoded as UTF-8. First
+ * use synchronously initializes WASM. The existing conservative nesting guard is
+ * an explicit binding resource limit, not an upstream grammar restriction.
+ * @public
+ */
+export declare function parseSync(source: string | Uint8Array, options?: ParseOptions): File_2;
+
+/**
+ * Parses once while observing every real node's upstream bounds in Go. The
+ * separate immutable lookup describes this original parse; it never replaces
+ * live nodePos/nodeEnd or tracks edits. Source adapters avoid reconstructing
+ * each descendant subtree just to display the original source locations.
+ * @public
+ */
+export declare function parseWithPositionsSync(source: string | Uint8Array, options?: ParseOptions): ParsedFile;
+
+/**
+ * Upstream BinCmdOperator constant Pipe. Its numeric value is preserved exactly.
+ *
+ * |
+ *
+ * @public
+ */
+export declare const Pipe: 13;
+
+/**
+ * Upstream BinCmdOperator constant PipeAll. Its numeric value is preserved exactly.
+ *
+ * |&
+ *
+ * @public
+ */
+export declare const PipeAll: 14;
+
+/**
+ * Upstream UnAritOperator constant Plus. Its numeric value is preserved exactly.
+ *
+ * +
+ *
+ * @public
+ */
+export declare const Plus: 81;
+
+/**
+ * Identity-based lookup of the original parse's bounds. A new or copied node has
+ * no observation. The index never calls WASM or recalculates edited node bounds.
+ * @public
+ */
+export declare interface PositionSnapshot {
+    /**
+     * Returns the captured pair for a node from this parse, or undefined for a
+     * foreign node. If either upstream observation failed, throws the captured
+     * InputError without changing the successfully parsed File. Use nodePos or
+     * nodeEnd to request a live, independent bound from current edited fields.
+     */
+    get(node: Node_2): NodePositions | undefined;
+}
+
+/**
+ * Upstream BinAritOperator constant Pow. Its numeric value is preserved exactly.
+ *
+ * **
+ *
+ * @public
+ */
+export declare const Pow: 44;
+
+/**
+ * Upstream BinAritOperator constant PowAssgn. Its numeric value is preserved exactly.
+ *
+ * **=
+ *
+ * @public
+ */
+export declare const PowAssgn: 62;
+
+/**
+ * An error returned by upstream Printer.Print, such as an unsupported root or
+ * incompatible formatting options. No partial writer output is exposed.
+ * @public
+ */
+export declare class PrintError extends ShAstError {
+    /** Stable identity for an ordinary error returned by upstream Print. @public */
+    readonly code = "SH_AST_SYNTAX_PRINT";
+    /** Exact upstream error bytes; Error.message is only a display rendering. @public */
+    readonly Message: GoString;
+    /** Retains the upstream error without interpreting its human-readable text. @public */
+    constructor(message: GoString);
+}
+
+/**
+ * Upstream NewPrinter controls applied to a fresh printer for each call. All
+ * flags default to false; zero indentation selects tabs. The pinned WASM uint
+ * domain is 64-bit, so Indent accepts bigint beyond JavaScript's safe integers.
+ * @public
+ */
+export declare interface PrintOptions {
+    /** Spaces per level, or zero for tabs. Large values can request expensive output. */
+    Indent?: number | bigint;
+    /** Places multiline binary operators on the next line with a backslash continuation. */
+    BinaryNextLine?: boolean;
+    /** Indents case alternatives, placing their bodies two levels below the case clause. */
+    SwitchCaseIndent?: boolean;
+    /** Adds space after redirection operators except `>&`, `<&`, `>(` and `<(`. */
+    SpaceRedirects?: boolean;
+    /**
+     * Preserves token columns on a best-effort basis.
+     * @deprecated Upstream marks this option as flawed and plans removal in v4.
+     */
+    KeepPadding?: boolean;
+    /** Omits comments, indentation and optional whitespace. Incompatible with SingleLine. */
+    Minify?: boolean;
+    /** Reduces newlines except where comments, heredocs or File output require them. */
+    SingleLine?: boolean;
+    /** Places a function's opening brace on the next line. */
+    FunctionNextLine?: boolean;
+}
+
+/**
+ * Upstream Printer.Print panicked for a representable tree or option value.
+ * Partial and typed-nil trees can trigger this independently of root support.
+ * Catching the panic preserves reuse of the binding's shared runtime.
+ * @public
+ */
+export declare class PrintPanicError extends ShAstError {
+    /** Stable identity for an upstream panic caught at the Print operation. @public */
+    readonly code = "SH_AST_SYNTAX_PRINT_PANIC";
+    /** Exact panic rendering from Go; Error.message is only a display rendering. @public */
+    readonly Message: GoString;
+    /** Retains the panic message separately from ordinary returned Print errors. @public */
+    constructor(message: GoString);
+}
+
+/**
+ * Formats the current tree with a fresh upstream printer and collects all output.
+ * Supported roots are File, Stmt, Word, Assign, Command and WordPart; other Nodes
+ * produce PrintError. Only File output has upstream's trailing-newline behavior.
+ * Invalid UTF-8 output remains bytes. Upstream formatting can itself consume
+ * input bytes, including its tabwriter escape byte, so this is not source replay.
+ *
+ * InputError identifies unrepresentable input; PrintError is an ordinary returned
+ * upstream error; PrintPanicError retains an upstream operation panic. No partial
+ * output or arbitrary writer lifecycle is exposed. Full tree reconstruction and
+ * collected output require memory proportional to the values involved; extreme
+ * indentation or tree size is not made resource-safe by panic adaptation.
+ * @public
+ */
+export declare function printSync(node: Node_2, options?: PrintOptions): GoString;
+
+/**
+ * The upstream ProcOperator domain: exact named tokens, the Go zero value, and explicitly validated unnamed uint32 values. Constants shared by upstream families retain their shared numeric identity.
+ *
+ * @public
+ */
+export declare type ProcOperator =
+0 | typeof CmdIn | typeof CmdInTemp | typeof CmdOut | RawOperator<'ProcOperator'>;
+
+/**
+ * ProcSubst represents a Bash process substitution.
+ *
+ * This node will only appear with `LangBash`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface ProcSubst {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'ProcSubst';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    Last: Comment_2[] | null;
+    /**
+     * Upstream operator value, preserving named tokens, zero, and explicitly represented raw uint32 values.
+     */
+    Op: ProcOperator;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    OpPos: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Rparen: SyntaxPos;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Stmts: (Stmt | null)[] | null;
+}
+
+/**
+ * Upstream BinAritOperator constant Quo. Its numeric value is preserved exactly.
+ *
+ * /
+ *
+ * @public
+ */
+export declare const Quo: 101;
+
+/**
+ * Upstream BinAritOperator constant QuoAssgn. Its numeric value is preserved exactly.
+ *
+ * /=
+ *
+ * @public
+ */
+export declare const QuoAssgn: 52;
+
+/**
+ * An explicitly represented unnamed uint32 value in one upstream operator family. The runtime constructor checks integer range; this type does not claim that every value is meaningful to every parser or printer operation. The structural family marker remains interoperable across package entry points while preventing accidental cross-family assignment.
+ *
+ * @public
+ */
+export declare type RawOperator<Family extends OperatorFamily> = number & {
+    readonly __shAstOperatorFamily: Family;
+};
+
+/**
+ * Represents an unnamed value in an upstream uint32 operator family. Named
+ * constants remain precise literal unions; this explicit path preserves other Go
+ * values without claiming an operation such as Print accepts them.
+ * @public
+ */
+export declare function rawOperator<Family extends OperatorFamily>(family: Family, value: number): RawOperator<Family>;
+
+/**
+ * Upstream RedirOperator constant RdrAll. Its numeric value is preserved exactly.
+ *
+ * &\>
+ *
+ * @public
+ */
+export declare const RdrAll: 74;
+
+/**
+ * Upstream RedirOperator constant RdrAllClob. Its numeric value is preserved exactly.
+ *
+ * &\>| with `LangZsh`
+ *
+ * @public
+ */
+export declare const RdrAllClob: 75;
+
+/**
+ * Upstream RedirOperator constant RdrClob. Its numeric value is preserved exactly.
+ *
+ * \>|
+ *
+ * @public
+ */
+export declare const RdrClob: 69;
+
+/**
+ * Upstream RedirOperator constant RdrIn. Its numeric value is preserved exactly.
+ *
+ * \<
+ *
+ * @public
+ */
+export declare const RdrIn: 65;
+
+/**
+ * Upstream RedirOperator constant RdrInOut. Its numeric value is preserved exactly.
+ *
+ * \<\>
+ *
+ * @public
+ */
+export declare const RdrInOut: 66;
+
+/**
+ * Upstream RedirOperator constant RdrOut. Its numeric value is preserved exactly.
+ *
+ * \>
+ *
+ * @public
+ */
+export declare const RdrOut: 63;
+
+/**
+ * Redirect represents an input/output redirection.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface Redirect {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'Redirect';
+    /**
+     * here-document body
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Hdoc: Word | null;
+    /**
+     * fd\>, or \{varname\}\> in Bash
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    N: Lit | null;
+    /**
+     * Upstream operator value, preserving named tokens, zero, and explicitly represented raw uint32 values.
+     */
+    Op: RedirOperator;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    OpPos: SyntaxPos;
+    /**
+     * \>word
+     *
+     * Null preserves the upstream absence of this component.
+     */
+    Word: Word | null;
+}
+
+/**
+ * The upstream RedirOperator domain: exact named tokens, the Go zero value, and explicitly validated unnamed uint32 values. Constants shared by upstream families retain their shared numeric identity.
+ *
+ * @public
+ */
+export declare type RedirOperator =
+| 0
+| typeof AppAll
+| typeof AppAllClob
+| typeof AppClob
+| typeof AppOut
+| typeof DashHdoc
+| typeof DplIn
+| typeof DplOut
+| typeof Hdoc
+| typeof RdrAll
+| typeof RdrAllClob
+| typeof RdrClob
+| typeof RdrIn
+| typeof RdrInOut
+| typeof RdrOut
+| typeof WordHdoc
+| RawOperator<'RedirOperator'>;
+
+/**
+ * Upstream BinAritOperator constant Rem. Its numeric value is preserved exactly.
+ *
+ * %
+ *
+ * @public
+ */
+export declare const Rem: 89;
+
+/**
+ * Upstream BinAritOperator constant RemAssgn. Its numeric value is preserved exactly.
+ *
+ * %=
+ *
+ * @public
+ */
+export declare const RemAssgn: 53;
+
+/**
+ * Upstream ParExpOperator constant RemLargePrefix. Its numeric value is preserved exactly.
+ *
+ * ##
+ *
+ * @public
+ */
+export declare const RemLargePrefix: 92;
+
+/**
+ * Upstream ParExpOperator constant RemLargeSuffix. Its numeric value is preserved exactly.
+ *
+ * %%
+ *
+ * @public
+ */
+export declare const RemLargeSuffix: 90;
+
+/**
+ * Upstream ParExpOperator constant RemSmallPrefix. Its numeric value is preserved exactly.
+ *
+ * #
+ *
+ * @public
+ */
+export declare const RemSmallPrefix: 91;
+
+/**
+ * Upstream ParExpOperator constant RemSmallSuffix. Its numeric value is preserved exactly.
+ *
+ * %
+ *
+ * @public
+ */
+export declare const RemSmallSuffix: 89;
+
+/**
+ * Replace represents a search and replace expression inside a `ParamExp`.
+ *
+ * Auxiliary syntax data, not a syntax.Node; it has no independent source bounds.
+ *
+ * @public
+ */
+export declare interface Replace {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'Replace';
+    /**
+     * False is an explicit upstream value and is never omitted.
+     */
+    All: boolean;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Orig: Word | null;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    With: Word | null;
+}
+
+/**
+ * Upstream CaseOperator constant Resume. Its numeric value is preserved exactly.
+ *
+ * ;;&
+ *
+ * @public
+ */
+export declare const Resume: 37;
+
+/**
+ * Upstream CaseOperator constant ResumeKorn. Its numeric value is preserved exactly.
+ *
+ * ;|
+ *
+ * @public
+ */
+export declare const ResumeKorn: 38;
+
+/**
+ * SglQuoted represents a string within single quotes.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface SglQuoted {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'SglQuoted';
+    /**
+     * $''
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Dollar: boolean;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Left: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Right: SyntaxPos;
+    /**
+     * Upstream string bytes; non-UTF-8 values remain bytes rather than replacement text.
+     */
+    Value: GoString;
+}
+
+/**
+ * Thrown by `sh-ast/analyze`'s `resolveArgv0` when a caller-supplied
+ * `options.transparentWrappers` array contains a malformed `WrapperSpec`
+ * entry — e.g. a non-array or empty `names`, or a flag field that isn't an
+ * array of strings. Fails closed with a clear, specific message at the
+ * point the malformed table is supplied, rather than letting the bad shape
+ * reach flag-matching logic and surface as a confusing native `TypeError`
+ * (or, worse, a silently wrong match) far from its actual cause.
+ *
+ * @public
+ */
+export declare class ShAnalyzeInvalidWrapperSpecError extends ShAstError {
+    readonly code = "SH_AST_ANALYZE_INVALID_WRAPPER_SPEC";
+    constructor(message: string);
+}
+
+/**
+ * Thrown by `sh-ast/analyze`'s `enumerateCommands` when a tree's genuinely
+ * nested structure — subshells within subshells, chained command/process
+ * substitutions, deeply nested `if`/`case`/loop/function/`time`/`{ }`
+ * bodies, deeply chained `elif` — exceeds its defensive recursion-depth
+ * guard. **Not** thrown for a long *linear* chain (`|`/`|&`/`&&`/`||` of
+ * any realistic length): `enumerateCommands` traverses those iteratively,
+ * so chain length alone never grows this guard's depth counter — only
+ * genuine tree nesting does.
+ *
+ * `enumerateCommands` deliberately fails closed here rather than returning
+ * a truncated, partial result: a partial `CommandSite[]` silently omits
+ * real command sites, which is a false negative for a permission-hook-style
+ * consumer that treats "command not found in the enumeration" as "nothing
+ * to worry about" — an explicit, documented throw is safer than a silent
+ * under-report. Gate-style consumers should treat this error as `deny`,
+ * not fall back to "no commands found, so allow".
+ *
+ * @public
+ */
+export declare class ShAnalyzeMaxDepthError extends ShAstError {
+    readonly code = "SH_AST_ANALYZE_MAX_DEPTH";
+    /** The maximum nesting depth `enumerateCommands` supports; the same value every time (not caller-configurable). */
+    readonly maxDepth: number;
+    constructor(maxDepth: number);
+}
+
+/** Shared failure classes for binding invariants, resource limits, and analysis contracts. */
+/**
+ * Common base for every package failure, including upstream syntax errors and
+ * analysis errors. The stable code discriminator supports programmatic handling
+ * without interpreting display messages. Only concrete subclasses are thrown.
  * @public
  */
-export declare interface ParseOptions {
+export declare abstract class ShAstError extends Error {
+    /** Stable machine-readable identity of the concrete failure kind. */
+    abstract readonly code: string;
+}
+
+/**
+ * Thrown by {@link parseSync} for failures that should never happen given a
+ * correctly-behaving WASM shim: a malformed result envelope, an unexpected
+ * root node type, or any other shim contract violation. Distinct from
+ * {@link InputError} and {@link ParseError}, both of which
+ * indicate a foreseeable, actionable user mistake rather than an internal
+ * defect.
+ *
+ * @public
+ */
+export declare class ShInternalError extends ShAstError {
+    readonly code = "SH_AST_INTERNAL";
+    constructor(message: string);
+}
+
+/**
+ * Upstream BinAritOperator constant Shl. Its numeric value is preserved exactly.
+ *
+ * \<\<
+ *
+ * @public
+ */
+export declare const Shl: 71;
+
+/**
+ * Upstream BinAritOperator constant ShlAssgn. Its numeric value is preserved exactly.
+ *
+ * \<\<=
+ *
+ * @public
+ */
+export declare const ShlAssgn: 57;
+
+/**
+ * Thrown by {@link parseSync} when `text`'s conservatively estimated
+ * structural nesting depth (subshells, command/process substitutions,
+ * `if`/`case`/loop/function bodies, `{ }` blocks, backtick or `$(...)`
+ * command substitution, `$((...))` arithmetic — see
+ * `parse-depth-guard.ts`'s module doc for the exact heuristic) exceeds the
+ * limit `parseSync` accepts. Thrown *before* `text` is ever handed to the
+ * WASM shim: mvdan/sh's own recursive-descent parser has no recovery path
+ * for exhausting its call stack on pathologically deep input (a stack
+ * overflow deep inside the shared WASM instance is not a normal, catchable
+ * JS error the way a parse syntax error is), so this bridge estimates the
+ * risk up front and fails closed with a typed error instead of ever making
+ * that call — the shared WASM instance is therefore never put at risk of
+ * wedging on this class of input; a `parseSync` call right after catching
+ * this error works exactly as it would if this input had never been
+ * attempted.
+ *
+ * Like {@link ShAnalyzeMaxDepthError}, this is pathological-input
+ * protection, not a normal-usage ceiling: a legitimately deep (but
+ * realistic) script parses fine. The estimate can *over*-count relative to
+ * mvdan/sh's real grammar (rejecting some legitimate-but-unusually-deep
+ * input) but is designed to never *under*-count relative to it — see
+ * `parse-depth-guard.ts` for the documented false-positive sources this
+ * trades off against ever letting a genuinely crash-inducing input
+ * through.
+ *
+ * @public
+ */
+export declare class ShParseMaxDepthError extends ShAstError {
+    readonly code = "SH_AST_PARSE_MAX_DEPTH";
+    /** The maximum structural nesting depth `parseSync` accepts; the same value every time (not caller-configurable). */
+    readonly maxDepth: number;
+    /**
+     * The conservatively estimated nesting depth that tripped the guard.
+     * Not necessarily `text`'s "true" nesting depth under a real parse — see
+     * {@link ShParseMaxDepthError}'s doc comment — only ever `> maxDepth`.
+     */
+    readonly estimatedDepth: number;
+    constructor(maxDepth: number, estimatedDepth: number);
+}
+
+/**
+ * Upstream BinAritOperator constant Shr. Its numeric value is preserved exactly.
+ *
+ * \>\>
+ *
+ * @public
+ */
+export declare const Shr: 64;
+
+/**
+ * Upstream BinAritOperator constant ShrAssgn. Its numeric value is preserved exactly.
+ *
+ * \>\>=
+ *
+ * @public
+ */
+export declare const ShrAssgn: 58;
+
+/**
+ * Slice represents a character slicing expression inside a `ParamExp`.
+ *
+ * This node will only appear with `LangBash` and `LangMirBSDKorn`.
+ * `LangZsh` uses a `BinaryArithm` with `Comma` in `ParamExp.Index` instead.
+ *
+ * Auxiliary syntax data, not a syntax.Node; it has no independent source bounds.
+ *
+ * @public
+ */
+export declare interface Slice {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'Slice';
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Length: ArithmExpr | null;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Offset: ArithmExpr | null;
+}
+
+/**
+ * Stmt represents a statement, also known as a "complete command". It is
+ * compromised of a command and other components that may come before or after
+ * it.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface Stmt {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'Stmt';
+    /**
+     * stmt &
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Background: boolean;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Cmd: Command | null;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    Comments: Comment_2[] | null;
+    /**
+     * mksh's |&
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Coprocess: boolean;
+    /**
+     * zsh's &| or &!
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Disown: boolean;
+    /**
+     * ! stmt
+     *
+     * False is an explicit upstream value and is never omitted.
+     */
+    Negated: boolean;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Position: SyntaxPos;
+    /**
+     * stmt \>a \<b
+     *
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Redirs: (Redirect | null)[] | null;
+    /**
+     * position of ';', '&', or '|&', if any
+     *
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Semicolon: SyntaxPos;
+}
+
+/**
+ * Upstream BinAritOperator constant Sub. Its numeric value is preserved exactly.
+ *
+ * -
+ *
+ * @public
+ */
+export declare const Sub: 83;
+
+/**
+ * Upstream BinAritOperator constant SubAssgn. Its numeric value is preserved exactly.
+ *
+ * -=
+ *
+ * @public
+ */
+export declare const SubAssgn: 50;
+
+/**
+ * Subshell represents a series of commands that should be executed in a nested
+ * shell environment.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface Subshell {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'Subshell';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    Last: Comment_2[] | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Lparen: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Rparen: SyntaxPos;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Stmts: (Stmt | null)[] | null;
+}
+
+/**
+ * Concrete alternatives for upstream syntax interfaces. Auxiliary records are
+ * absent from Node; consumers must preserve that distinction in their adapters.
+ * @public
+ */
+export declare const SYNTAX_INTERFACES: Readonly<Readonly<Record<string, readonly string[]>>>;
+
+/**
+ * Complete upstream field metadata for validating or adapting syntax records.
+ * Metadata order is not the upstream Walk visitation order. Shared records are
+ * deeply frozen even though the syntax values they describe are mutable.
+ * @public
+ */
+export declare const SYNTAX_SCHEMA: Readonly<Readonly<Record<string, SyntaxRecordSchema>>>;
+
+/**
+ * A field's upstream value kind and nil-bearing boundaries. Null type names
+ * identify scalar/position kinds; other names identify concrete Go types.
+ * @public
+ */
+export declare interface SyntaxFieldSchema {
+    /** The upstream value domain, independent of a field's current value. */
+    readonly kind: 'boolean' | 'string' | 'position' | 'operator' | 'struct' | 'interface';
+    /** Named operator, record, or interface domain; null for scalar/position data. */
+    readonly type: string | null;
+    /** Whether the entire field may hold the upstream nil value. */
+    readonly nullable: boolean;
+    /** Whether the field is an ordered Go slice, preserving nil versus empty. */
+    readonly slice: boolean;
+    /** Whether a slice element may independently hold a nil pointer/interface. */
+    readonly elementNullable: boolean;
+}
+
+/**
+ * The observable value of an upstream syntax.Pos. Offset and Col count bytes; Line and Col use upstream numbering and overflow behavior. IsValid, IsRecovered, and OffsetOverflow retain distinctions that coordinates alone cannot express. Token positions are data; node bounds are derived operations.
+ *
+ * @public
+ */
+export declare interface SyntaxPos {
+    /**
+     * Zero-based source byte offset, including upstream saturation behavior.
+     */
+    Offset: number;
+    /**
+     * One-based source line; zero retains upstream invalid or overflow information.
+     */
+    Line: number;
+    /**
+     * One-based byte column; zero retains upstream invalid or overflow information.
+     */
+    Col: number;
+    /**
+     * Whether upstream considers this position useful; recovered positions are not valid.
+     */
+    IsValid: boolean;
+    /**
+     * Whether upstream synthesized this missing syntax position during error recovery.
+     */
+    IsRecovered: boolean;
+    /**
+     * Whether the stored upstream offset exceeds its representable source-offset maximum, including the recovered sentinel. This preserves ordering distinctions even when Offset() reports zero; ordinary zero-invalid positions have false here.
+     */
+    OffsetOverflow: boolean;
+}
+
+/** Complete data fields and real syntax.Node membership. @public */
+export declare interface SyntaxRecordSchema {
+    /** Whether the actual upstream type implements syntax.Node. */
+    readonly node: boolean;
+    /** Every exported upstream field, retaining its original spelling. */
+    readonly fields: Readonly<Record<string, SyntaxFieldSchema>>;
+}
+
+/**
+ * Upstream BinAritOperator constant TernColon. Its numeric value is preserved exactly.
+ *
+ * :
+ *
+ * @public
+ */
+export declare const TernColon: 104;
+
+/**
+ * Upstream BinAritOperator constant TernQuest. Its numeric value is preserved exactly.
+ *
+ * ?
+ *
+ * @public
+ */
+export declare const TernQuest: 85;
+
+/**
+ * TestClause represents a Bash extended test clause.
+ *
+ * This node will only appear with `LangBash` and `LangMirBSDKorn`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
+ *
+ * @public
+ */
+export declare interface TestClause {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'TestClause';
     /**
-     * The shell dialect to parse against.
-     * @defaultValue `"bash"`
+     * Recorded source position; invalid and recovered states remain distinct.
      */
-    readonly dialect?: ShellDialect;
+    Left: SyntaxPos;
     /**
-     * Filename used only to annotate error messages and positions; the source
-     * is never read from disk.
-     * @defaultValue `"input.sh"`
+     * Recorded source position; invalid and recovered states remain distinct.
      */
-    readonly filename?: string;
+    Right: SyntaxPos;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    X: TestExpr | null;
 }
 
 /**
- * Synchronously parses shell source into a normalized AST.
+ * TestDecl represents the declaration of a Bats test function.
  *
- * The first call instantiates the WASM shim synchronously (Node-only); the
- * instance is reused across subsequent calls, so repeated calls do not
- * re-instantiate (see design/ARCHITECTURE.md).
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
  *
- * Throws {@link ShParseError} on a shell syntax error, carrying the position
- * mvdan/sh reported: `.line` is 1-based exactly as mvdan/sh reports it;
- * `.column` is converted to UTF-16 code units so it agrees with
- * {@link ShNode.loc}'s columns (mvdan/sh itself reports `column` as a byte
- * count — see {@link ShParseErrorInfo.column}). That unconverted, raw
- * position appears only inside `.message`, which is mvdan/sh's own
- * formatted string, verbatim. Throws {@link ShInvalidDialectError} when
- * {@link ParseOptions.dialect} is not a supported dialect. Throws
- * {@link ShInternalError} for failures that should never happen given
- * a correctly-behaving shim (malformed envelope, unexpected root node
- * type, shim contract violations). Throws {@link ShParseMaxDepthError} if
- * `text`'s conservatively estimated structural nesting depth exceeds the
- * limit this bridge accepts — checked, and thrown, *before* `text` is ever
- * handed to the WASM shim, since mvdan/sh's own parser has no recovery path
- * for exhausting its stack on pathological nesting (see that error's doc
- * comment and `parse-depth-guard.ts`).
+ * @public
+ */
+export declare interface TestDecl {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'TestDecl';
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Body: Stmt | null;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Description: Word | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Position: SyntaxPos;
+}
+
+/**
+ * The concrete records and typed nil pointers accepted by upstream syntax.TestExpr. Typed nil kinds are limited to this interface's actual implementers; auxiliary records are excluded.
  *
  * @public
  */
-export declare function parseSync(text: string, options?: ParseOptions): ShFile;
+export declare type TestExpr =
+| BinaryTest
+| ParenTest
+| UnaryTest
+| Word
+| TypedNil<'BinaryTest' | 'ParenTest' | 'UnaryTest' | 'Word'>;
 
 /**
- * A 1-based line/column position. Columns are UTF-16 code units, matching
- * JavaScript string indexing (see {@link ShNode.range}).
+ * TimeClause represents a Bash time clause. PosixFormat corresponds to the -p
+ * flag.
+ *
+ * This node will only appear with `LangBash` and `LangMirBSDKorn`.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
  *
  * @public
  */
-export declare interface Position {
-    readonly line: number;
-    readonly column: number;
+export declare interface TimeClause {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'TimeClause';
+    /**
+     * False is an explicit upstream value and is never omitted.
+     */
+    PosixFormat: boolean;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Stmt: Stmt | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    Time: SyntaxPos;
 }
 
 /**
- * Thrown by `sh-ast/analyze`'s `resolveArgv0` when a caller-supplied
- * `options.transparentWrappers` array contains a malformed `WrapperSpec`
- * entry — e.g. a non-array or empty `names`, or a flag field that isn't an
- * array of strings. Fails closed with a clear, specific message at the
- * point the malformed table is supplied, rather than letting the bad shape
- * reach flag-matching logic and surface as a confusing native `TypeError`
- * (or, worse, a silently wrong match) far from its actual cause.
+ * Upstream BinTestOperator constant TsAfter. Its numeric value is preserved exactly.
+ *
+ * \>
+ *
+ * @public
+ */
+export declare const TsAfter: 63;
+
+/**
+ * Upstream BinTestOperator constant TsBefore. Its numeric value is preserved exactly.
+ *
+ * \<
+ *
+ * @public
+ */
+export declare const TsBefore: 65;
+
+/**
+ * Upstream UnTestOperator constant TsBlckSp. Its numeric value is preserved exactly.
+ *
+ * -b
  *
  * @public
  */
-export declare class ShAnalyzeInvalidWrapperSpecError extends ShAstError {
-    readonly code = "SH_AST_ANALYZE_INVALID_WRAPPER_SPEC";
-    constructor(message: string);
-}
+export declare const TsBlckSp: 109;
 
 /**
- * Thrown by `sh-ast/analyze`'s `enumerateCommands` when a tree's genuinely
- * nested structure — subshells within subshells, chained command/process
- * substitutions, deeply nested `if`/`case`/loop/function/`time`/`{ }`
- * bodies, deeply chained `elif` — exceeds its defensive recursion-depth
- * guard. **Not** thrown for a long *linear* chain (`|`/`|&`/`&&`/`||` of
- * any realistic length): `enumerateCommands` traverses those iteratively,
- * so chain length alone never grows this guard's depth counter — only
- * genuine tree nesting does.
+ * Upstream UnTestOperator constant TsCharSp. Its numeric value is preserved exactly.
  *
- * `enumerateCommands` deliberately fails closed here rather than returning
- * a truncated, partial result: a partial `CommandSite[]` silently omits
- * real command sites, which is a false negative for a permission-hook-style
- * consumer that treats "command not found in the enumeration" as "nothing
- * to worry about" — an explicit, documented throw is safer than a silent
- * under-report. Gate-style consumers should treat this error as `deny`,
- * not fall back to "no commands found, so allow".
+ * -c
  *
  * @public
  */
-export declare class ShAnalyzeMaxDepthError extends ShAstError {
-    readonly code = "SH_AST_ANALYZE_MAX_DEPTH";
-    /** The maximum nesting depth `enumerateCommands` supports; the same value every time (not caller-configurable). */
-    readonly maxDepth: number;
-    constructor(maxDepth: number);
-}
+export declare const TsCharSp: 108;
 
 /**
- * The union of every normalized node type this bridge can produce.
+ * Upstream BinTestOperator constant TsDevIno. Its numeric value is preserved exactly.
+ *
+ * -ef
  *
  * @public
  */
-declare type ShAnyNode =
-| ShArithmCmdNode
-| ShArithmExpNode
-| ShArrayElemNode
-| ShArrayExprNode
-| ShAssignNode
-| ShBinaryArithmNode
-| ShBinaryCmdNode
-| ShBinaryTestNode
-| ShBlockNode
-| ShBraceExpNode
-| ShCStyleLoopNode
-| ShCallExprNode
-| ShCaseClauseNode
-| ShCaseItemNode
-| ShCmdSubstNode
-| ShCommentNode
-| ShCoprocClauseNode
-| ShDblQuotedNode
-| ShDeclClauseNode
-| ShExpansionNode
-| ShExtGlobNode
-| ShFileNode
-| ShFlagsArithmNode
-| ShForClauseNode
-| ShFuncDeclNode
-| ShIfClauseNode
-| ShLetClauseNode
-| ShLitNode
-| ShParamExpNode
-| ShParenArithmNode
-| ShParenTestNode
-| ShProcSubstNode
-| ShRedirectNode
-| ShReplaceNode
-| ShSglQuotedNode
-| ShSliceNode
-| ShStmtNode
-| ShSubshellNode
-| ShTestClauseNode
-| ShTestDeclNode
-| ShTimeClauseNode
-| ShUnaryArithmNode
-| ShUnaryTestNode
-| ShWhileClauseNode
-| ShWordNode
-| ShWordIterNode;
+export declare const TsDevIno: 132;
 
 /**
- * mvdan/sh's `syntax.ArithmCmd`, normalized.
+ * Upstream UnTestOperator constant TsDirect. Its numeric value is preserved exactly.
+ *
+ * -d
  *
  * @public
  */
-declare interface ShArithmCmdNode {
-    readonly type: 'ArithmCmd';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly unsigned?: boolean;
-    readonly x?: ShArithmExprNode;
-}
+export declare const TsDirect: 107;
 
 /**
- * mvdan/sh's `syntax.ArithmExp`, normalized.
+ * Upstream UnTestOperator constant TsEmpStr. Its numeric value is preserved exactly.
+ *
+ * -z
  *
  * @public
  */
-declare interface ShArithmExpNode {
-    readonly type: 'ArithmExp';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly bracket?: boolean;
-    readonly unsigned?: boolean;
-    readonly x?: ShArithmExprNode;
-}
+export declare const TsEmpStr: 124;
 
 /**
- * The union of concrete node types mvdan/sh's `syntax.ArithmExpr` interface can
- * hold.
+ * Upstream BinTestOperator constant TsEql. Its numeric value is preserved exactly.
+ *
+ * -eq
  *
  * @public
  */
-declare type ShArithmExprNode =
-ShBinaryArithmNode | ShFlagsArithmNode | ShParenArithmNode | ShUnaryArithmNode | ShWordNode;
+export declare const TsEql: 133;
 
 /**
- * mvdan/sh's `syntax.ArrayElem`, normalized.
+ * Upstream UnTestOperator constant TsExec. Its numeric value is preserved exactly.
+ *
+ * -x
  *
  * @public
  */
-declare interface ShArrayElemNode {
-    readonly type: 'ArrayElem';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly comments: readonly ShCommentNode[];
-    readonly index?: ShArithmExprNode;
-    readonly value?: ShWordNode;
-}
+export declare const TsExec: 121;
 
 /**
- * mvdan/sh's `syntax.ArrayExpr`, normalized.
+ * Upstream UnTestOperator constant TsExists. Its numeric value is preserved exactly.
+ *
+ * -e
  *
  * @public
  */
-declare interface ShArrayExprNode {
-    readonly type: 'ArrayExpr';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly elems: readonly ShArrayElemNode[];
-    readonly last: readonly ShCommentNode[];
-}
+export declare const TsExists: 105;
 
 /**
- * mvdan/sh's `syntax.Assign`, normalized.
+ * Upstream UnTestOperator constant TsFdTerm. Its numeric value is preserved exactly.
+ *
+ * -t
  *
  * @public
  */
-declare interface ShAssignNode {
-    readonly type: 'Assign';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly append?: boolean;
-    readonly array?: ShArrayExprNode;
-    readonly index?: ShArithmExprNode;
-    readonly naked?: boolean;
-    readonly name?: ShLitNode;
-    readonly value?: ShWordNode;
-}
+export declare const TsFdTerm: 123;
 
 /**
- * Common base class for every error this package throws — originally just
- * {@link sh-ast#parseSync | parseSync}'s errors, now also the
- * `sh-ast/analyze` layer's (see {@link ShAnalyzeMaxDepthError},
- * {@link ShAnalyzeInvalidWrapperSpecError}). Provides a stable, documented
- * `code` discriminator (e.g. `"SH_AST_PARSE_ERROR"`) alongside the usual
- * `instanceof` narrowing, so consumers can branch on failure kind
- * programmatically without parsing `.message` strings. Never thrown directly
- * — only via its concrete subclasses
- * ({@link sh-ast#ShParseError | ShParseError},
- * {@link sh-ast#ShInvalidDialectError | ShInvalidDialectError},
- * {@link sh-ast#ShInternalError | ShInternalError},
- * {@link ShAnalyzeMaxDepthError},
- * {@link sh-ast#ShParseMaxDepthError | ShParseMaxDepthError},
- * {@link ShAnalyzeInvalidWrapperSpecError}).
+ * Upstream BinTestOperator constant TsGeq. Its numeric value is preserved exactly.
  *
- * Re-exported from `sh-ast/analyze` as well as the root `sh-ast` entry
- * point (see #23) — every subclass thrown by `sh-ast/analyze`'s own
- * functions extends this, so a consumer of that subpath alone can
- * `catch`/reference the base without also importing from root.
+ * -ge
  *
  * @public
  */
-export declare abstract class ShAstError extends Error {
-    /**
-     * Stable, machine-readable discriminator for this error kind. Distinct
-     * per subclass and will not change once published.
-     */
-    abstract readonly code: string;
-}
+export declare const TsGeq: 136;
 
 /**
- * mvdan/sh's `syntax.BinaryArithm`, normalized.
+ * Upstream UnTestOperator constant TsGIDSet. Its numeric value is preserved exactly.
+ *
+ * -g
  *
  * @public
  */
-declare interface ShBinaryArithmNode {
-    readonly type: 'BinaryArithm';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly op?: number;
-    readonly x?: ShArithmExprNode;
-    readonly y?: ShArithmExprNode;
-}
+export declare const TsGIDSet: 114;
 
 /**
- * mvdan/sh's `syntax.BinaryCmd`, normalized.
+ * Upstream UnTestOperator constant TsGrpOwn. Its numeric value is preserved exactly.
+ *
+ * -G
  *
  * @public
  */
-declare interface ShBinaryCmdNode {
-    readonly type: 'BinaryCmd';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly op?: number;
-    readonly x?: ShStmtNode;
-    readonly y?: ShStmtNode;
-}
+export declare const TsGrpOwn: 116;
 
 /**
- * mvdan/sh's `syntax.BinaryTest`, normalized.
+ * Upstream BinTestOperator constant TsGtr. Its numeric value is preserved exactly.
+ *
+ * -gt
  *
  * @public
  */
-declare interface ShBinaryTestNode {
-    readonly type: 'BinaryTest';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly op?: number;
-    readonly x?: ShTestExprNode;
-    readonly y?: ShTestExprNode;
-}
+export declare const TsGtr: 138;
 
 /**
- * mvdan/sh's `syntax.Block`, normalized.
+ * Upstream BinTestOperator constant TsLeq. Its numeric value is preserved exactly.
+ *
+ * -le
  *
  * @public
  */
-declare interface ShBlockNode {
-    readonly type: 'Block';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly last: readonly ShCommentNode[];
-    readonly stmts: readonly ShStmtNode[];
-}
+export declare const TsLeq: 135;
 
 /**
- * mvdan/sh's `syntax.BraceExp`, normalized.
+ * Upstream BinTestOperator constant TsLss. Its numeric value is preserved exactly.
+ *
+ * -lt
  *
  * @public
  */
-declare interface ShBraceExpNode {
-    readonly type: 'BraceExp';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly elems: readonly ShWordNode[];
-    readonly sequence?: boolean;
-}
+export declare const TsLss: 137;
 
 /**
- * mvdan/sh's `syntax.CallExpr`, normalized.
+ * Upstream BinTestOperator constant TsMatch. Its numeric value is preserved exactly.
+ *
+ * ==
  *
  * @public
  */
-declare interface ShCallExprNode {
-    readonly type: 'CallExpr';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly args: readonly ShWordNode[];
-    readonly assigns: readonly ShAssignNode[];
-}
+export declare const TsMatch: 45;
 
 /**
- * mvdan/sh's `syntax.CaseClause`, normalized.
+ * Upstream BinTestOperator constant TsMatchShort. Its numeric value is preserved exactly.
+ *
+ * =
  *
  * @public
  */
-declare interface ShCaseClauseNode {
-    readonly type: 'CaseClause';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly braces?: boolean;
-    readonly items: readonly ShCaseItemNode[];
-    readonly last: readonly ShCommentNode[];
-    readonly word?: ShWordNode;
-}
+export declare const TsMatchShort: 87;
 
 /**
- * mvdan/sh's `syntax.CaseItem`, normalized.
+ * Upstream UnTestOperator constant TsModif. Its numeric value is preserved exactly.
+ *
+ * -N
  *
  * @public
  */
-declare interface ShCaseItemNode {
-    readonly type: 'CaseItem';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly comments: readonly ShCommentNode[];
-    readonly last: readonly ShCommentNode[];
-    readonly op?: number;
-    readonly patterns: readonly ShWordNode[];
-    readonly stmts: readonly ShStmtNode[];
-}
+export declare const TsModif: 118;
 
 /**
- * mvdan/sh's `syntax.CmdSubst`, normalized.
+ * Upstream UnTestOperator constant TsNempStr. Its numeric value is preserved exactly.
+ *
+ * -n
  *
  * @public
  */
-declare interface ShCmdSubstNode {
-    readonly type: 'CmdSubst';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly backquotes?: boolean;
-    readonly last: readonly ShCommentNode[];
-    readonly replyvar?: boolean;
-    readonly stmts: readonly ShStmtNode[];
-    readonly tempfile?: boolean;
-}
+export declare const TsNempStr: 125;
 
 /**
- * The union of concrete node types mvdan/sh's `syntax.Command` interface can
- * hold.
+ * Upstream BinTestOperator constant TsNeq. Its numeric value is preserved exactly.
+ *
+ * -ne
  *
  * @public
  */
-declare type ShCommandNode =
-| ShArithmCmdNode
-| ShBinaryCmdNode
-| ShBlockNode
-| ShCallExprNode
-| ShCaseClauseNode
-| ShCoprocClauseNode
-| ShDeclClauseNode
-| ShForClauseNode
-| ShFuncDeclNode
-| ShIfClauseNode
-| ShLetClauseNode
-| ShSubshellNode
-| ShTestClauseNode
-| ShTestDeclNode
-| ShTimeClauseNode
-| ShWhileClauseNode;
+export declare const TsNeq: 134;
 
 /**
- * mvdan/sh's `syntax.Comment`, normalized.
+ * Upstream BinTestOperator constant TsNewer. Its numeric value is preserved exactly.
+ *
+ * -nt
  *
  * @public
  */
-declare interface ShCommentNode {
-    readonly type: 'Comment';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly text?: string;
-}
+export declare const TsNewer: 130;
 
 /**
- * mvdan/sh's `syntax.CoprocClause`, normalized.
+ * Upstream UnTestOperator constant TsNmPipe. Its numeric value is preserved exactly.
+ *
+ * -p
  *
  * @public
  */
-declare interface ShCoprocClauseNode {
-    readonly type: 'CoprocClause';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly name?: ShWordNode;
-    readonly stmt?: ShStmtNode;
-}
+export declare const TsNmPipe: 110;
 
 /**
- * mvdan/sh's `syntax.CStyleLoop`, normalized.
+ * Upstream UnTestOperator constant TsNoEmpty. Its numeric value is preserved exactly.
+ *
+ * -s
  *
  * @public
  */
-declare interface ShCStyleLoopNode {
-    readonly type: 'CStyleLoop';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly cond?: ShArithmExprNode;
-    readonly init?: ShArithmExprNode;
-    readonly post?: ShArithmExprNode;
-}
+export declare const TsNoEmpty: 122;
 
 /**
- * mvdan/sh's `syntax.DblQuoted`, normalized.
+ * Upstream BinTestOperator constant TsNoMatch. Its numeric value is preserved exactly.
+ *
+ * !=
  *
  * @public
  */
-declare interface ShDblQuotedNode {
-    readonly type: 'DblQuoted';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly dollar?: boolean;
-    readonly parts: readonly ShWordPartNode[];
-}
+export declare const TsNoMatch: 46;
 
 /**
- * mvdan/sh's `syntax.DeclClause`, normalized.
+ * Upstream UnTestOperator constant TsNot. Its numeric value is preserved exactly.
+ *
+ * !
  *
  * @public
  */
-declare interface ShDeclClauseNode {
-    readonly type: 'DeclClause';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly args: readonly ShAssignNode[];
-    readonly variant?: ShLitNode;
-}
+export declare const TsNot: 39;
 
 /**
- * Shell dialect (mvdan/sh `LangVariant`) to parse against. Mapped to
- * `LangVariant` by string name via `LangVariant.Set()` — never by numeric
- * value, since the bit-flag encoding of `LangVariant` is not a stable
- * contract across mvdan/sh versions. See design/ARCHITECTURE.md, "Parse
- * errors and dialects".
+ * Upstream BinTestOperator constant TsOlder. Its numeric value is preserved exactly.
+ *
+ * -ot
  *
  * @public
  */
-export declare type ShellDialect = 'bash' | 'posix' | 'mksh' | 'bats' | 'zsh';
+export declare const TsOlder: 131;
 
 /**
- * mvdan/sh's `syntax.Expansion`, normalized.
+ * Upstream UnTestOperator constant TsOptSet. Its numeric value is preserved exactly.
+ *
+ * -o
  *
  * @public
  */
-declare interface ShExpansionNode {
-    readonly type: 'Expansion';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly op?: number;
-    readonly word?: ShWordNode;
-}
+export declare const TsOptSet: 126;
 
 /**
- * mvdan/sh's `syntax.ExtGlob`, normalized.
+ * Upstream UnTestOperator constant TsParen. Its numeric value is preserved exactly.
+ *
+ * (
  *
  * @public
  */
-declare interface ShExtGlobNode {
-    readonly type: 'ExtGlob';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly op?: number;
-    readonly pattern?: ShLitNode;
-}
+export declare const TsParen: 27;
 
 /**
- * The root node of a parsed shell script.
+ * Upstream UnTestOperator constant TsRead. Its numeric value is preserved exactly.
+ *
+ * -r
  *
  * @public
  */
-export declare interface ShFile extends ShNode {
-    readonly type: 'File';
-    readonly stmts: readonly ShNode[];
-}
+export declare const TsRead: 119;
 
 /**
- * mvdan/sh's `syntax.File`, normalized.
+ * Upstream UnTestOperator constant TsRefVar. Its numeric value is preserved exactly.
+ *
+ * -R
  *
  * @public
  */
-declare interface ShFileNode {
-    readonly type: 'File';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly last: readonly ShCommentNode[];
-    readonly name?: string;
-    readonly stmts: readonly ShStmtNode[];
-}
+export declare const TsRefVar: 128;
 
 /**
- * mvdan/sh's `syntax.FlagsArithm`, normalized.
+ * Upstream UnTestOperator constant TsRegFile. Its numeric value is preserved exactly.
+ *
+ * -f
  *
  * @public
  */
-declare interface ShFlagsArithmNode {
-    readonly type: 'FlagsArithm';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly flags?: ShLitNode;
-    readonly x?: ShArithmExprNode;
-}
+export declare const TsRegFile: 106;
 
 /**
- * mvdan/sh's `syntax.ForClause`, normalized.
+ * Upstream BinTestOperator constant TsReMatch. Its numeric value is preserved exactly.
+ *
+ * =~
  *
  * @public
  */
-declare interface ShForClauseNode {
-    readonly type: 'ForClause';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly braces?: boolean;
-    readonly do: readonly ShStmtNode[];
-    readonly dolast: readonly ShCommentNode[];
-    readonly loop?: ShLoopNode;
-    readonly select?: boolean;
-}
+export declare const TsReMatch: 129;
 
 /**
- * mvdan/sh's `syntax.FuncDecl`, normalized.
+ * Upstream UnTestOperator constant TsSmbLink. Its numeric value is preserved exactly.
+ *
+ * -L
  *
  * @public
  */
-declare interface ShFuncDeclNode {
-    readonly type: 'FuncDecl';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly body?: ShStmtNode;
-    readonly name?: ShLitNode;
-    readonly names: readonly ShLitNode[];
-    readonly parens?: boolean;
-    readonly rsrvword?: boolean;
-}
+export declare const TsSmbLink: 112;
 
 /**
- * mvdan/sh's `syntax.IfClause`, normalized.
+ * Upstream UnTestOperator constant TsSocket. Its numeric value is preserved exactly.
+ *
+ * -S
  *
  * @public
  */
-declare interface ShIfClauseNode {
-    readonly type: 'IfClause';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly cond: readonly ShStmtNode[];
-    readonly condlast: readonly ShCommentNode[];
-    readonly else?: ShIfClauseNode;
-    readonly last: readonly ShCommentNode[];
-    readonly then: readonly ShStmtNode[];
-    readonly thenlast: readonly ShCommentNode[];
-}
+export declare const TsSocket: 111;
 
 /**
- * Thrown by {@link parseSync} for failures that should never happen given a
- * correctly-behaving WASM shim: a malformed result envelope, an unexpected
- * root node type, or any other shim contract violation. Distinct from
- * {@link ShInvalidDialectError} and {@link ShParseError}, both of which
- * indicate a foreseeable, actionable user mistake rather than an internal
- * defect.
+ * Upstream UnTestOperator constant TsSticky. Its numeric value is preserved exactly.
+ *
+ * -k
  *
  * @public
  */
-export declare class ShInternalError extends ShAstError {
-    readonly code = "SH_AST_INTERNAL";
-    constructor(message: string);
-}
+export declare const TsSticky: 113;
 
 /**
- * Thrown by {@link parseSync} when {@link ParseOptions.dialect} is not one
- * of the supported {@link ShellDialect} values. Carries the rejected value
- * as `.dialect`; `.message` lists the supported dialects. A foreseeable,
- * actionable user mistake — never an instance of {@link ShParseError}.
+ * Upstream UnTestOperator constant TsUIDSet. Its numeric value is preserved exactly.
+ *
+ * -u
  *
  * @public
  */
-export declare class ShInvalidDialectError extends ShAstError {
-    readonly code = "SH_AST_INVALID_DIALECT";
-    /** The rejected dialect value, exactly as passed to {@link parseSync}. */
-    readonly dialect: string;
-    constructor(dialect: string, supportedDialects: readonly ShellDialect[]);
-}
+export declare const TsUIDSet: 115;
 
 /**
- * mvdan/sh's `syntax.LetClause`, normalized.
+ * Upstream UnTestOperator constant TsUsrOwn. Its numeric value is preserved exactly.
+ *
+ * -O
  *
  * @public
  */
-declare interface ShLetClauseNode {
-    readonly type: 'LetClause';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly exprs: readonly ShArithmExprNode[];
-}
-
-/**
- * mvdan/sh's `syntax.Lit`, normalized.
- *
- * @public
- */
-declare interface ShLitNode {
-    readonly type: 'Lit';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly value?: string;
-}
+export declare const TsUsrOwn: 117;
 
 /**
- * The union of concrete node types mvdan/sh's `syntax.Loop` interface can
- * hold.
+ * Upstream UnTestOperator constant TsVarSet. Its numeric value is preserved exactly.
+ *
+ * -v
  *
  * @public
  */
-declare type ShLoopNode = ShCStyleLoopNode | ShWordIterNode;
+export declare const TsVarSet: 127;
 
 /**
- * A normalized AST node produced by {@link sh-ast#parseSync | parseSync}.
- *
- * `range` and `loc` are expressed in UTF-16 code units, so
- * `code.slice(node.range[0], node.range[1])` reproduces the node's exact
- * source text — even though mvdan/sh itself reports byte offsets and
- * byte-counting columns internally (see design/ARCHITECTURE.md's
- * "Serialization contract"). Every other field copied over from mvdan/sh's
- * typedjson tree keeps its original value but with the field name
- * lowercased (`Stmts` becomes `stmts`, `CondLast` becomes `condlast`, etc.).
+ * Upstream UnTestOperator constant TsWrite. Its numeric value is preserved exactly.
  *
- * Also re-exported from `sh-ast/analyze` (see #23) — the subpath's public
- * surface consumes and exposes `ShNode`, so a consumer can reference the type
- * without also importing from the root `sh-ast` entry point.
+ * -w
  *
  * @public
  */
-export declare interface ShNode {
-    readonly type: string;
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: Position;
-        readonly end: Position;
-    };
-    [field: string]: unknown;
-}
+export declare const TsWrite: 120;
 
-export declare namespace ShNodes {
-    export {
-        ShArithmCmdNode,
-        ShArithmExpNode,
-        ShArrayElemNode,
-        ShArrayExprNode,
-        ShAssignNode,
-        ShBinaryArithmNode,
-        ShBinaryCmdNode,
-        ShBinaryTestNode,
-        ShBlockNode,
-        ShBraceExpNode,
-        ShCStyleLoopNode,
-        ShCallExprNode,
-        ShCaseClauseNode,
-        ShCaseItemNode,
-        ShCmdSubstNode,
-        ShCommentNode,
-        ShCoprocClauseNode,
-        ShDblQuotedNode,
-        ShDeclClauseNode,
-        ShExpansionNode,
-        ShExtGlobNode,
-        ShFileNode,
-        ShFlagsArithmNode,
-        ShForClauseNode,
-        ShFuncDeclNode,
-        ShIfClauseNode,
-        ShLetClauseNode,
-        ShLitNode,
-        ShParamExpNode,
-        ShParenArithmNode,
-        ShParenTestNode,
-        ShProcSubstNode,
-        ShRedirectNode,
-        ShReplaceNode,
-        ShSglQuotedNode,
-        ShSliceNode,
-        ShStmtNode,
-        ShSubshellNode,
-        ShTestClauseNode,
-        ShTestDeclNode,
-        ShTimeClauseNode,
-        ShUnaryArithmNode,
-        ShUnaryTestNode,
-        ShWhileClauseNode,
-        ShWordNode,
-        ShWordIterNode,
-        ShArithmExprNode,
-        ShCommandNode,
-        ShLoopNode,
-        ShTestExprNode,
-        ShWordPartNode,
-        ShAnyNode,
-        ShNodeTypeName
-    }
-}
-
-/**
- * Every normalized node `type` string this bridge can produce.
- *
- * @public
- */
-declare type ShNodeTypeName =
+/**
+ * An upstream interface containing a nil pointer of a concrete syntax.Node kind. This differs from a nil interface (null): the concrete Go type remains observable and can affect operations. Only interface-valued positions admit this tag; concrete pointer fields use null. No record fields or node bounds are stored on the tag.
+ *
+ * @public
+ */
+export declare interface TypedNil<
+ConcreteKind extends
 | 'ArithmCmd'
 | 'ArithmExp'
 | 'ArrayElem'
@@ -887,7 +3604,6 @@ declare type ShNodeTypeName =
 | 'CoprocClause'
 | 'DblQuoted'
 | 'DeclClause'
-| 'Expansion'
 | 'ExtGlob'
 | 'File'
 | 'FlagsArithm'
@@ -901,9 +3617,7 @@ declare type ShNodeTypeName =
 | 'ParenTest'
 | 'ProcSubst'
 | 'Redirect'
-| 'Replace'
 | 'SglQuoted'
-| 'Slice'
 | 'Stmt'
 | 'Subshell'
 | 'TestClause'
@@ -913,478 +3627,360 @@ declare type ShNodeTypeName =
 | 'UnaryTest'
 | 'WhileClause'
 | 'Word'
-| 'WordIter';
-
-/**
- * mvdan/sh's `syntax.ParamExp`, normalized.
- *
- * @public
- */
-declare interface ShParamExpNode {
-    readonly type: 'ParamExp';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly excl?: boolean;
-    readonly exp?: ShExpansionNode;
-    readonly flags?: ShLitNode;
-    readonly index?: ShArithmExprNode;
-    readonly isset?: boolean;
-    readonly length?: boolean;
-    readonly modifiers: readonly ShLitNode[];
-    readonly names?: number;
-    readonly nestedparam?: ShWordPartNode;
-    readonly param?: ShLitNode;
-    readonly repl?: ShReplaceNode;
-    readonly short?: boolean;
-    readonly slice?: ShSliceNode;
-    readonly width?: boolean;
+| 'WordIter',
+> {
+    /**
+     * Distinguishes a typed nil interface value from a concrete syntax record.
+     */
+    Type: 'TypedNil';
+    /**
+     * The concrete Go pointer type retained by the non-nil interface.
+     */
+    Kind: ConcreteKind;
 }
 
 /**
- * mvdan/sh's `syntax.ParenArithm`, normalized.
+ * The upstream UnAritOperator domain: exact named tokens, the Go zero value, and explicitly validated unnamed uint32 values. Constants shared by upstream families retain their shared numeric identity.
  *
  * @public
  */
-declare interface ShParenArithmNode {
-    readonly type: 'ParenArithm';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly x?: ShArithmExprNode;
-}
+export declare type UnAritOperator =
+| 0
+| typeof BitNegation
+| typeof Dec
+| typeof Inc
+| typeof Minus
+| typeof Not
+| typeof Plus
+| RawOperator<'UnAritOperator'>;
 
 /**
- * mvdan/sh's `syntax.ParenTest`, normalized.
+ * UnaryArithm represents an unary arithmetic expression. The unary operator
+ * may come before or after the sub-expression.
  *
- * @public
- */
-declare interface ShParenTestNode {
-    readonly type: 'ParenTest';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly x?: ShTestExprNode;
-}
-
-/**
- * Thrown by {@link parseSync} when shell source fails to parse. Carries the
- * real position mvdan/sh reported — never 1:1 placeholders: `.line` is
- * 1-based exactly as mvdan/sh reports it, and `.column` is converted to
- * UTF-16 code units so it agrees with {@link ShNode.loc}'s columns (mvdan/sh
- * itself reports `column` as a byte count on the source line — see
- * {@link ShParseErrorInfo.column}). The unconverted, raw byte-column
- * position appears only inside `.message`, mvdan/sh's own formatted string,
- * verbatim.
+ * If Op is `Inc` or `Dec`, X will be a word with a single `Lit` whose value is a
+ * valid name.
  *
- * @public
- */
-export declare class ShParseError extends ShAstError {
-    readonly code = "SH_AST_PARSE_ERROR";
-    readonly line: number;
-    readonly column: number;
-    readonly filename: string;
-    constructor(message: string, info: ShParseErrorInfo);
-}
-
-/**
- * Position info attached to a {@link ShParseError}.
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
  *
  * @public
  */
-export declare interface ShParseErrorInfo {
-    /** 1-based line number, exactly as reported by mvdan/sh. */
-    line: number;
+export declare interface UnaryArithm {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'UnaryArithm';
+    /**
+     * Upstream operator value, preserving named tokens, zero, and explicitly represented raw uint32 values.
+     */
+    Op: UnAritOperator;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    OpPos: SyntaxPos;
+    /**
+     * False is an explicit upstream value and is never omitted.
+     */
+    Post: boolean;
     /**
-     * 1-based column number, in **UTF-16 code units** — converted from
-     * mvdan/sh's own byte-counting column so it agrees with
-     * {@link ShNode.loc}'s columns (mvdan/sh reports `column` as a byte count
-     * on the source line, not a UTF-16 code unit count; see
-     * design/ARCHITECTURE.md's "Byte→UTF-16 conversion"). For ASCII-only
-     * source text this is numerically identical to mvdan/sh's own column.
+     * Null preserves the upstream absence of this component.
      */
-    column: number;
-    /** The filename used for the parse (see {@link ParseOptions.filename}). */
-    filename: string;
+    X: ArithmExpr | null;
 }
 
 /**
- * Thrown by {@link parseSync} when `text`'s conservatively estimated
- * structural nesting depth (subshells, command/process substitutions,
- * `if`/`case`/loop/function bodies, `{ }` blocks, backtick or `$(...)`
- * command substitution, `$((...))` arithmetic — see
- * `parse-depth-guard.ts`'s module doc for the exact heuristic) exceeds the
- * limit `parseSync` accepts. Thrown *before* `text` is ever handed to the
- * WASM shim: mvdan/sh's own recursive-descent parser has no recovery path
- * for exhausting its call stack on pathologically deep input (a stack
- * overflow deep inside the shared WASM instance is not a normal, catchable
- * JS error the way a parse syntax error is), so this bridge estimates the
- * risk up front and fails closed with a typed error instead of ever making
- * that call — the shared WASM instance is therefore never put at risk of
- * wedging on this class of input; a `parseSync` call right after catching
- * this error works exactly as it would if this input had never been
- * attempted.
+ * UnaryTest represents a unary test expression. The unary operator may come
+ * before or after the sub-expression.
  *
- * Like {@link ShAnalyzeMaxDepthError}, this is pathological-input
- * protection, not a normal-usage ceiling: a legitimately deep (but
- * realistic) script parses fine. The estimate can *over*-count relative to
- * mvdan/sh's real grammar (rejecting some legitimate-but-unusually-deep
- * input) but is designed to never *under*-count relative to it — see
- * `parse-depth-guard.ts` for the documented false-positive sources this
- * trades off against ever letting a genuinely crash-inducing input
- * through.
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
  *
  * @public
  */
-export declare class ShParseMaxDepthError extends ShAstError {
-    readonly code = "SH_AST_PARSE_MAX_DEPTH";
-    /** The maximum structural nesting depth `parseSync` accepts; the same value every time (not caller-configurable). */
-    readonly maxDepth: number;
+export declare interface UnaryTest {
     /**
-     * The conservatively estimated nesting depth that tripped the guard.
-     * Not necessarily `text`'s "true" nesting depth under a real parse — see
-     * {@link ShParseMaxDepthError}'s doc comment — only ever `> maxDepth`.
+     * Identifies the upstream concrete record when carried through an interface union.
      */
-    readonly estimatedDepth: number;
-    constructor(maxDepth: number, estimatedDepth: number);
+    Type: 'UnaryTest';
+    /**
+     * Upstream operator value, preserving named tokens, zero, and explicitly represented raw uint32 values.
+     */
+    Op: UnTestOperator;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    OpPos: SyntaxPos;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    X: TestExpr | null;
 }
 
 /**
- * mvdan/sh's `syntax.ProcSubst`, normalized.
+ * The upstream UnTestOperator domain: exact named tokens, the Go zero value, and explicitly validated unnamed uint32 values. Constants shared by upstream families retain their shared numeric identity.
  *
  * @public
  */
-declare interface ShProcSubstNode {
-    readonly type: 'ProcSubst';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly last: readonly ShCommentNode[];
-    readonly op?: number;
-    readonly stmts: readonly ShStmtNode[];
-}
+export declare type UnTestOperator =
+| 0
+| typeof TsBlckSp
+| typeof TsCharSp
+| typeof TsDirect
+| typeof TsEmpStr
+| typeof TsExec
+| typeof TsExists
+| typeof TsFdTerm
+| typeof TsGIDSet
+| typeof TsGrpOwn
+| typeof TsModif
+| typeof TsNempStr
+| typeof TsNmPipe
+| typeof TsNoEmpty
+| typeof TsNot
+| typeof TsOptSet
+| typeof TsParen
+| typeof TsRead
+| typeof TsRefVar
+| typeof TsRegFile
+| typeof TsSmbLink
+| typeof TsSocket
+| typeof TsSticky
+| typeof TsUIDSet
+| typeof TsUsrOwn
+| typeof TsVarSet
+| typeof TsWrite
+| RawOperator<'UnTestOperator'>;
 
 /**
- * mvdan/sh's `syntax.Redirect`, normalized.
+ * Upstream ParExpOperator constant UpperAll. Its numeric value is preserved exactly.
  *
- * @public
- */
-declare interface ShRedirectNode {
-    readonly type: 'Redirect';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly hdoc?: ShWordNode;
-    readonly n?: ShLitNode;
-    readonly op?: number;
-    readonly word?: ShWordNode;
-}
-
-/**
- * mvdan/sh's `syntax.Replace`, normalized.
+ * ^^
  *
  * @public
  */
-declare interface ShReplaceNode {
-    readonly type: 'Replace';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly all?: boolean;
-    readonly orig?: ShWordNode;
-    readonly with?: ShWordNode;
-}
+export declare const UpperAll: 97;
 
 /**
- * mvdan/sh's `syntax.SglQuoted`, normalized.
+ * Upstream ParExpOperator constant UpperFirst. Its numeric value is preserved exactly.
  *
- * @public
- */
-declare interface ShSglQuotedNode {
-    readonly type: 'SglQuoted';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly dollar?: boolean;
-    readonly value?: string;
-}
-
-/**
- * mvdan/sh's `syntax.Slice`, normalized.
+ * ^
  *
  * @public
  */
-declare interface ShSliceNode {
-    readonly type: 'Slice';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly length?: ShArithmExprNode;
-    readonly offset?: ShArithmExprNode;
-}
+export declare const UpperFirst: 96;
 
 /**
- * mvdan/sh's `syntax.Stmt`, normalized.
+ * Walks synchronously using the pinned upstream case ordering. Each accepted entry is followed by its
+ * children and a null exit. Returning false prunes the entry without an exit;
+ * boolean exit return values are ignored. Every callback must return a boolean
+ * synchronously; other results produce InputError. Callback exceptions retain their identity,
+ * and upstream deferred comment callbacks still run during exception unwinding.
  *
- * @public
- */
-declare interface ShStmtNode {
-    readonly type: 'Stmt';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly background?: boolean;
-    readonly cmd?: ShCommandNode;
-    readonly comments: readonly ShCommentNode[];
-    readonly coprocess?: boolean;
-    readonly disown?: boolean;
-    readonly negated?: boolean;
-    readonly redirs: readonly ShRedirectNode[];
-}
-
-/**
- * mvdan/sh's `syntax.Subshell`, normalized.
+ * Children and later fields are read live. Each list captures its array reference
+ * and length when traversal reaches that list, then reads existing later slots
+ * when reached. Replacing or reordering later slots is observed and can cause
+ * a node to be skipped or revisited. Indices added beyond the captured extent
+ * are not visited by that active list. Replacing the owner's array field does not
+ * redirect an active list, but a later walk or print sees the current field.
+ * Changes made before a list is reached are observed when it starts.
  *
- * @public
- */
-declare interface ShSubshellNode {
-    readonly type: 'Subshell';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly last: readonly ShCommentNode[];
-    readonly stmts: readonly ShStmtNode[];
-}
-
-/**
- * mvdan/sh's `syntax.TestClause`, normalized.
+ * Supported edits preserve each node's Type (and TypedNil.Kind), required field
+ * shapes and every index within each active list's captured extent. Leaving
+ * holes or shrinking an array below that extent (for example through truncation,
+ * deletion, or length-reducing splice/shift) is outside the mutation contract.
+ * These are not runtime validation rules. Ordinary JavaScript object and array
+ * aliases remain shared; the binding does not model distinct Go slice headers or
+ * capacity-dependent allocation over shared backing storage.
  *
+ * Comments on Stmt, CaseItem and ArrayElem are copied before their callbacks,
+ * including position and byte-string values; editing a copy does not edit the
+ * stored comment. Last/CondLast/ThenLast/DoLast callbacks receive the stored
+ * JavaScript Comment object. Replacing its array slot leaves any previously
+ * retained callback object unchanged: there is no Go value-slot pointer identity.
+ * Reentrant walks maintain independent traversal state.
  * @public
  */
-declare interface ShTestClauseNode {
-    readonly type: 'TestClause';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly x?: ShTestExprNode;
-}
+export declare function walk(node: Node_2, callback: (node: Node_2 | null) => boolean): void;
 
 /**
- * mvdan/sh's `syntax.TestDecl`, normalized.
- *
+ * A panic raised by upstream-equivalent traversal, such as a nil dereference or
+ * unsupported concrete node. Exceptions thrown by callbacks are never wrapped.
  * @public
  */
-declare interface ShTestDeclNode {
-    readonly type: 'TestDecl';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly body?: ShStmtNode;
-    readonly description?: ShWordNode;
+export declare class WalkPanicError extends ShAstError {
+    /** Stable discriminator for traversal panics. @public */
+    readonly code = "SH_AST_WALK_PANIC";
+    /** Exact upstream panic bytes; Error.message is only a display rendering. @public */
+    readonly Message: GoString;
+    /** Retains the upstream panic text separately from its display rendering. @public */
+    constructor(message: GoString);
 }
 
 /**
- * The union of concrete node types mvdan/sh's `syntax.TestExpr` interface can
- * hold.
+ * WhileClause represents a while or an until clause.
  *
- * @public
- */
-declare type ShTestExprNode = ShBinaryTestNode | ShParenTestNode | ShUnaryTestNode | ShWordNode;
-
-/**
- * mvdan/sh's `syntax.TimeClause`, normalized.
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
  *
  * @public
  */
-declare interface ShTimeClauseNode {
-    readonly type: 'TimeClause';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly posixformat?: boolean;
-    readonly stmt?: ShStmtNode;
+export declare interface WhileClause {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'WhileClause';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Cond: (Stmt | null)[] | null;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    CondLast: Comment_2[] | null;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Do: (Stmt | null)[] | null;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array.
+     */
+    DoLast: Comment_2[] | null;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    DoPos: SyntaxPos;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    DonePos: SyntaxPos;
+    /**
+     * False is an explicit upstream value and is never omitted.
+     */
+    Until: boolean;
+    /**
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    WhilePos: SyntaxPos;
 }
 
 /**
- * mvdan/sh's `syntax.UnaryArithm`, normalized.
+ * Word represents a shell word, containing one or more word parts contiguous to
+ * each other. The word is delimited by word boundaries, such as spaces,
+ * newlines, semicolons, or parentheses.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
  *
  * @public
  */
-declare interface ShUnaryArithmNode {
-    readonly type: 'UnaryArithm';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly op?: number;
-    readonly post?: boolean;
-    readonly x?: ShArithmExprNode;
+export declare interface Word {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'Word';
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Parts: (WordPart | null)[] | null;
 }
 
 /**
- * mvdan/sh's `syntax.UnaryTest`, normalized.
+ * Upstream RedirOperator constant WordHdoc. Its numeric value is preserved exactly.
+ *
+ * \<\<\<
  *
  * @public
  */
-declare interface ShUnaryTestNode {
-    readonly type: 'UnaryTest';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly op?: number;
-    readonly x?: ShTestExprNode;
-}
+export declare const WordHdoc: 73;
 
 /**
- * mvdan/sh's `syntax.WhileClause`, normalized.
+ * WordIter represents the iteration of a variable over a series of words in a
+ * for clause. If InPos is an invalid position, the "in" token was missing, so
+ * the iteration is over the shell's positional parameters.
+ *
+ * A syntax node with mutable upstream fields. Its source bounds are derived from the current fields and children.
  *
  * @public
  */
-declare interface ShWhileClauseNode {
-    readonly type: 'WhileClause';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly cond: readonly ShStmtNode[];
-    readonly condlast: readonly ShCommentNode[];
-    readonly do: readonly ShStmtNode[];
-    readonly dolast: readonly ShCommentNode[];
-    readonly until?: boolean;
+export declare interface WordIter {
+    /**
+     * Identifies the upstream concrete record when carried through an interface union.
+     */
+    Type: 'WordIter';
+    /**
+     * position of "in"
+     *
+     * Recorded source position; invalid and recovered states remain distinct.
+     */
+    InPos: SyntaxPos;
+    /**
+     * Ordered upstream entries. Null preserves a nil slice and differs from an empty array. Null entries preserve nil elements.
+     */
+    Items: (Word | null)[] | null;
+    /**
+     * Null preserves the upstream absence of this component.
+     */
+    Name: Lit | null;
 }
 
 /**
- * mvdan/sh's `syntax.WordIter`, normalized.
+ * The concrete records and typed nil pointers accepted by upstream syntax.WordPart. Typed nil kinds are limited to this interface's actual implementers; auxiliary records are excluded.
  *
  * @public
  */
-declare interface ShWordIterNode {
-    readonly type: 'WordIter';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly items: readonly ShWordNode[];
-    readonly name?: ShLitNode;
-}
+export declare type WordPart =
+| ArithmExp
+| BraceExp
+| CmdSubst
+| DblQuoted
+| ExtGlob
+| Lit
+| ParamExp
+| ProcSubst
+| SglQuoted
+| TypedNil<
+| 'ArithmExp'
+| 'BraceExp'
+| 'CmdSubst'
+| 'DblQuoted'
+| 'ExtGlob'
+| 'Lit'
+| 'ParamExp'
+| 'ProcSubst'
+| 'SglQuoted'
+>;
 
 /**
- * mvdan/sh's `syntax.Word`, normalized.
+ * Upstream BinAritOperator constant Xor. Its numeric value is preserved exactly.
+ *
+ * ^
  *
  * @public
  */
-declare interface ShWordNode {
-    readonly type: 'Word';
-    readonly range: readonly [number, number];
-    readonly loc: {
-        readonly start: { readonly line: number; readonly column: number };
-        readonly end: { readonly line: number; readonly column: number };
-    };
-    [field: string]: unknown;
-    readonly parts: readonly ShWordPartNode[];
-}
+export declare const Xor: 96;
 
 /**
- * The union of concrete node types mvdan/sh's `syntax.WordPart` interface can
- * hold.
+ * Upstream BinAritOperator constant XorAssgn. Its numeric value is preserved exactly.
+ *
+ * ^=
  *
  * @public
  */
-declare type ShWordPartNode =
-| ShArithmExpNode
-| ShBraceExpNode
-| ShCmdSubstNode
-| ShDblQuotedNode
-| ShExtGlobNode
-| ShLitNode
-| ShParamExpNode
-| ShProcSubstNode
-| ShSglQuotedNode;
+export declare const XorAssgn: 56;
 
 /**
- * Maps each normalized node `type` to the field names (lowercased, matching
- * the normalized node shape produced by `normalize`) whose values hold child
- * nodes.
- *
- * Generated from mvdan/sh's `syntax` package struct definitions by
- * `tools/gen-visitor-keys` (see design/ARCHITECTURE.md, "The schema table is
- * generated, not hand-written") — this module only re-exports the generated
- * table under the public name, frozen. {@link walk} does not depend on this
- * table for correctness — it discovers children structurally — so any gap
- * here (there shouldn't be one; the kitchen-sink golden test guards it)
- * affects only external consumers that choose to traverse via this table.
+ * Upstream BinAritOperator constant XorBool. Its numeric value is preserved exactly.
  *
- * Frozen (including each per-type field-name array) so immutability of this
- * shared, module-scoped table is a contract, not just a convention any
- * importer happens to honor.
+ * ^^
  *
  * @public
  */
-export declare const visitorKeys: Readonly<Record<string, readonly string[]>>;
+export declare const XorBool: 97;
 
 /**
- * Visits every node in a normalized tree, pre-order (parent before
- * children), starting at `node`.
+ * Upstream BinAritOperator constant XorBoolAssgn. Its numeric value is preserved exactly.
  *
- * Children are discovered structurally: any field on a visited node whose
- * value is itself a normalized node (or an array of normalized nodes) is
- * treated as a child. This is deliberately not driven off {@link
- * visitorKeys} — the spike's hand-written visitor-keys table missed
- * `DeclClause.Variant` (see design/ARCHITECTURE.md) and silently
- * under-walked the tree, and `visitorKeys` remains hand-maintained pending a
- * schema generator (tracked separately). Walking structurally means this
- * function's completeness never depends on that table's accuracy.
+ * ^^=
  *
  * @public
  */
-export declare function walk(node: ShNode, visit: (node: ShNode, parent: ShNode | null) => void): void;
+export declare const XorBoolAssgn: 61;
 
 export { }