eure_tree/
constructors.rs

1//! This file was generated by `eure-gen`.
2//! Do not edit manually.
3use crate::builder::{BuilderNodeId, CstBuilder};
4use crate::node_kind::{NonTerminalKind, TerminalKind};
5///Branded type for Hash terminal
6#[derive(Debug, Clone)]
7pub struct HashToken {
8    pub(super) node_id: BuilderNodeId,
9    pub(super) builder: CstBuilder,
10}
11impl HashToken {
12    /// Consume this token and return its builder
13    pub fn into_builder(self) -> CstBuilder {
14        self.builder
15    }
16}
17impl From<HashToken> for BuilderNodeId {
18    fn from(token: HashToken) -> Self {
19        token.node_id
20    }
21}
22///Branded type for MapBind terminal
23#[derive(Debug, Clone)]
24pub struct MapBindToken {
25    pub(super) node_id: BuilderNodeId,
26    pub(super) builder: CstBuilder,
27}
28impl MapBindToken {
29    /// Consume this token and return its builder
30    pub fn into_builder(self) -> CstBuilder {
31        self.builder
32    }
33}
34impl From<MapBindToken> for BuilderNodeId {
35    fn from(token: MapBindToken) -> Self {
36        token.node_id
37    }
38}
39///Branded type for Integer terminal
40#[derive(Debug, Clone)]
41pub struct IntegerToken {
42    pub(super) node_id: BuilderNodeId,
43    pub(super) builder: CstBuilder,
44}
45impl IntegerToken {
46    /// Consume this token and return its builder
47    pub fn into_builder(self) -> CstBuilder {
48        self.builder
49    }
50}
51impl From<IntegerToken> for BuilderNodeId {
52    fn from(token: IntegerToken) -> Self {
53        token.node_id
54    }
55}
56///Branded type for Float terminal
57#[derive(Debug, Clone)]
58pub struct FloatToken {
59    pub(super) node_id: BuilderNodeId,
60    pub(super) builder: CstBuilder,
61}
62impl FloatToken {
63    /// Consume this token and return its builder
64    pub fn into_builder(self) -> CstBuilder {
65        self.builder
66    }
67}
68impl From<FloatToken> for BuilderNodeId {
69    fn from(token: FloatToken) -> Self {
70        token.node_id
71    }
72}
73///Branded type for Inf terminal
74#[derive(Debug, Clone)]
75pub struct InfToken {
76    pub(super) node_id: BuilderNodeId,
77    pub(super) builder: CstBuilder,
78}
79impl InfToken {
80    /// Consume this token and return its builder
81    pub fn into_builder(self) -> CstBuilder {
82        self.builder
83    }
84}
85impl From<InfToken> for BuilderNodeId {
86    fn from(token: InfToken) -> Self {
87        token.node_id
88    }
89}
90///Branded type for NaN terminal
91#[derive(Debug, Clone)]
92pub struct NaNToken {
93    pub(super) node_id: BuilderNodeId,
94    pub(super) builder: CstBuilder,
95}
96impl NaNToken {
97    /// Consume this token and return its builder
98    pub fn into_builder(self) -> CstBuilder {
99        self.builder
100    }
101}
102impl From<NaNToken> for BuilderNodeId {
103    fn from(token: NaNToken) -> Self {
104        token.node_id
105    }
106}
107///Branded type for True terminal
108#[derive(Debug, Clone)]
109pub struct TrueToken {
110    pub(super) node_id: BuilderNodeId,
111    pub(super) builder: CstBuilder,
112}
113impl TrueToken {
114    /// Consume this token and return its builder
115    pub fn into_builder(self) -> CstBuilder {
116        self.builder
117    }
118}
119impl From<TrueToken> for BuilderNodeId {
120    fn from(token: TrueToken) -> Self {
121        token.node_id
122    }
123}
124///Branded type for False terminal
125#[derive(Debug, Clone)]
126pub struct FalseToken {
127    pub(super) node_id: BuilderNodeId,
128    pub(super) builder: CstBuilder,
129}
130impl FalseToken {
131    /// Consume this token and return its builder
132    pub fn into_builder(self) -> CstBuilder {
133        self.builder
134    }
135}
136impl From<FalseToken> for BuilderNodeId {
137    fn from(token: FalseToken) -> Self {
138        token.node_id
139    }
140}
141///Branded type for Null terminal
142#[derive(Debug, Clone)]
143pub struct NullToken {
144    pub(super) node_id: BuilderNodeId,
145    pub(super) builder: CstBuilder,
146}
147impl NullToken {
148    /// Consume this token and return its builder
149    pub fn into_builder(self) -> CstBuilder {
150        self.builder
151    }
152}
153impl From<NullToken> for BuilderNodeId {
154    fn from(token: NullToken) -> Self {
155        token.node_id
156    }
157}
158///Branded type for Hole terminal
159#[derive(Debug, Clone)]
160pub struct HoleToken {
161    pub(super) node_id: BuilderNodeId,
162    pub(super) builder: CstBuilder,
163}
164impl HoleToken {
165    /// Consume this token and return its builder
166    pub fn into_builder(self) -> CstBuilder {
167        self.builder
168    }
169}
170impl From<HoleToken> for BuilderNodeId {
171    fn from(token: HoleToken) -> Self {
172        token.node_id
173    }
174}
175///Branded type for Str terminal
176#[derive(Debug, Clone)]
177pub struct StrToken {
178    pub(super) node_id: BuilderNodeId,
179    pub(super) builder: CstBuilder,
180}
181impl StrToken {
182    /// Consume this token and return its builder
183    pub fn into_builder(self) -> CstBuilder {
184        self.builder
185    }
186}
187impl From<StrToken> for BuilderNodeId {
188    fn from(token: StrToken) -> Self {
189        token.node_id
190    }
191}
192///Branded type for LitStr terminal
193#[derive(Debug, Clone)]
194pub struct LitStrToken {
195    pub(super) node_id: BuilderNodeId,
196    pub(super) builder: CstBuilder,
197}
198impl LitStrToken {
199    /// Consume this token and return its builder
200    pub fn into_builder(self) -> CstBuilder {
201        self.builder
202    }
203}
204impl From<LitStrToken> for BuilderNodeId {
205    fn from(token: LitStrToken) -> Self {
206        token.node_id
207    }
208}
209///Branded type for Text terminal
210#[derive(Debug, Clone)]
211pub struct TextToken {
212    pub(super) node_id: BuilderNodeId,
213    pub(super) builder: CstBuilder,
214}
215impl TextToken {
216    /// Consume this token and return its builder
217    pub fn into_builder(self) -> CstBuilder {
218        self.builder
219    }
220}
221impl From<TextToken> for BuilderNodeId {
222    fn from(token: TextToken) -> Self {
223        token.node_id
224    }
225}
226///Branded type for InlineCode1 terminal
227#[derive(Debug, Clone)]
228pub struct InlineCode1Token {
229    pub(super) node_id: BuilderNodeId,
230    pub(super) builder: CstBuilder,
231}
232impl InlineCode1Token {
233    /// Consume this token and return its builder
234    pub fn into_builder(self) -> CstBuilder {
235        self.builder
236    }
237}
238impl From<InlineCode1Token> for BuilderNodeId {
239    fn from(token: InlineCode1Token) -> Self {
240        token.node_id
241    }
242}
243///Branded type for LitStr3Start terminal
244#[derive(Debug, Clone)]
245pub struct LitStr3StartToken {
246    pub(super) node_id: BuilderNodeId,
247    pub(super) builder: CstBuilder,
248}
249impl LitStr3StartToken {
250    /// Consume this token and return its builder
251    pub fn into_builder(self) -> CstBuilder {
252        self.builder
253    }
254}
255impl From<LitStr3StartToken> for BuilderNodeId {
256    fn from(token: LitStr3StartToken) -> Self {
257        token.node_id
258    }
259}
260///Branded type for LitStr2Start terminal
261#[derive(Debug, Clone)]
262pub struct LitStr2StartToken {
263    pub(super) node_id: BuilderNodeId,
264    pub(super) builder: CstBuilder,
265}
266impl LitStr2StartToken {
267    /// Consume this token and return its builder
268    pub fn into_builder(self) -> CstBuilder {
269        self.builder
270    }
271}
272impl From<LitStr2StartToken> for BuilderNodeId {
273    fn from(token: LitStr2StartToken) -> Self {
274        token.node_id
275    }
276}
277///Branded type for LitStr1Start terminal
278#[derive(Debug, Clone)]
279pub struct LitStr1StartToken {
280    pub(super) node_id: BuilderNodeId,
281    pub(super) builder: CstBuilder,
282}
283impl LitStr1StartToken {
284    /// Consume this token and return its builder
285    pub fn into_builder(self) -> CstBuilder {
286        self.builder
287    }
288}
289impl From<LitStr1StartToken> for BuilderNodeId {
290    fn from(token: LitStr1StartToken) -> Self {
291        token.node_id
292    }
293}
294///Branded type for DelimCodeStart3 terminal
295#[derive(Debug, Clone)]
296pub struct DelimCodeStart3Token {
297    pub(super) node_id: BuilderNodeId,
298    pub(super) builder: CstBuilder,
299}
300impl DelimCodeStart3Token {
301    /// Consume this token and return its builder
302    pub fn into_builder(self) -> CstBuilder {
303        self.builder
304    }
305}
306impl From<DelimCodeStart3Token> for BuilderNodeId {
307    fn from(token: DelimCodeStart3Token) -> Self {
308        token.node_id
309    }
310}
311///Branded type for DelimCodeStart2 terminal
312#[derive(Debug, Clone)]
313pub struct DelimCodeStart2Token {
314    pub(super) node_id: BuilderNodeId,
315    pub(super) builder: CstBuilder,
316}
317impl DelimCodeStart2Token {
318    /// Consume this token and return its builder
319    pub fn into_builder(self) -> CstBuilder {
320        self.builder
321    }
322}
323impl From<DelimCodeStart2Token> for BuilderNodeId {
324    fn from(token: DelimCodeStart2Token) -> Self {
325        token.node_id
326    }
327}
328///Branded type for DelimCodeStart1 terminal
329#[derive(Debug, Clone)]
330pub struct DelimCodeStart1Token {
331    pub(super) node_id: BuilderNodeId,
332    pub(super) builder: CstBuilder,
333}
334impl DelimCodeStart1Token {
335    /// Consume this token and return its builder
336    pub fn into_builder(self) -> CstBuilder {
337        self.builder
338    }
339}
340impl From<DelimCodeStart1Token> for BuilderNodeId {
341    fn from(token: DelimCodeStart1Token) -> Self {
342        token.node_id
343    }
344}
345///Branded type for CodeBlockStart3 terminal
346#[derive(Debug, Clone)]
347pub struct CodeBlockStart3Token {
348    pub(super) node_id: BuilderNodeId,
349    pub(super) builder: CstBuilder,
350}
351impl CodeBlockStart3Token {
352    /// Consume this token and return its builder
353    pub fn into_builder(self) -> CstBuilder {
354        self.builder
355    }
356}
357impl From<CodeBlockStart3Token> for BuilderNodeId {
358    fn from(token: CodeBlockStart3Token) -> Self {
359        token.node_id
360    }
361}
362///Branded type for CodeBlockStart4 terminal
363#[derive(Debug, Clone)]
364pub struct CodeBlockStart4Token {
365    pub(super) node_id: BuilderNodeId,
366    pub(super) builder: CstBuilder,
367}
368impl CodeBlockStart4Token {
369    /// Consume this token and return its builder
370    pub fn into_builder(self) -> CstBuilder {
371        self.builder
372    }
373}
374impl From<CodeBlockStart4Token> for BuilderNodeId {
375    fn from(token: CodeBlockStart4Token) -> Self {
376        token.node_id
377    }
378}
379///Branded type for CodeBlockStart5 terminal
380#[derive(Debug, Clone)]
381pub struct CodeBlockStart5Token {
382    pub(super) node_id: BuilderNodeId,
383    pub(super) builder: CstBuilder,
384}
385impl CodeBlockStart5Token {
386    /// Consume this token and return its builder
387    pub fn into_builder(self) -> CstBuilder {
388        self.builder
389    }
390}
391impl From<CodeBlockStart5Token> for BuilderNodeId {
392    fn from(token: CodeBlockStart5Token) -> Self {
393        token.node_id
394    }
395}
396///Branded type for CodeBlockStart6 terminal
397#[derive(Debug, Clone)]
398pub struct CodeBlockStart6Token {
399    pub(super) node_id: BuilderNodeId,
400    pub(super) builder: CstBuilder,
401}
402impl CodeBlockStart6Token {
403    /// Consume this token and return its builder
404    pub fn into_builder(self) -> CstBuilder {
405        self.builder
406    }
407}
408impl From<CodeBlockStart6Token> for BuilderNodeId {
409    fn from(token: CodeBlockStart6Token) -> Self {
410        token.node_id
411    }
412}
413///Branded type for CodeBlockEnd3 terminal
414#[derive(Debug, Clone)]
415pub struct CodeBlockEnd3Token {
416    pub(super) node_id: BuilderNodeId,
417    pub(super) builder: CstBuilder,
418}
419impl CodeBlockEnd3Token {
420    /// Consume this token and return its builder
421    pub fn into_builder(self) -> CstBuilder {
422        self.builder
423    }
424}
425impl From<CodeBlockEnd3Token> for BuilderNodeId {
426    fn from(token: CodeBlockEnd3Token) -> Self {
427        token.node_id
428    }
429}
430///Branded type for Backtick2 terminal
431#[derive(Debug, Clone)]
432pub struct Backtick2Token {
433    pub(super) node_id: BuilderNodeId,
434    pub(super) builder: CstBuilder,
435}
436impl Backtick2Token {
437    /// Consume this token and return its builder
438    pub fn into_builder(self) -> CstBuilder {
439        self.builder
440    }
441}
442impl From<Backtick2Token> for BuilderNodeId {
443    fn from(token: Backtick2Token) -> Self {
444        token.node_id
445    }
446}
447///Branded type for CodeBlockEnd4 terminal
448#[derive(Debug, Clone)]
449pub struct CodeBlockEnd4Token {
450    pub(super) node_id: BuilderNodeId,
451    pub(super) builder: CstBuilder,
452}
453impl CodeBlockEnd4Token {
454    /// Consume this token and return its builder
455    pub fn into_builder(self) -> CstBuilder {
456        self.builder
457    }
458}
459impl From<CodeBlockEnd4Token> for BuilderNodeId {
460    fn from(token: CodeBlockEnd4Token) -> Self {
461        token.node_id
462    }
463}
464///Branded type for Backtick3 terminal
465#[derive(Debug, Clone)]
466pub struct Backtick3Token {
467    pub(super) node_id: BuilderNodeId,
468    pub(super) builder: CstBuilder,
469}
470impl Backtick3Token {
471    /// Consume this token and return its builder
472    pub fn into_builder(self) -> CstBuilder {
473        self.builder
474    }
475}
476impl From<Backtick3Token> for BuilderNodeId {
477    fn from(token: Backtick3Token) -> Self {
478        token.node_id
479    }
480}
481///Branded type for CodeBlockEnd5 terminal
482#[derive(Debug, Clone)]
483pub struct CodeBlockEnd5Token {
484    pub(super) node_id: BuilderNodeId,
485    pub(super) builder: CstBuilder,
486}
487impl CodeBlockEnd5Token {
488    /// Consume this token and return its builder
489    pub fn into_builder(self) -> CstBuilder {
490        self.builder
491    }
492}
493impl From<CodeBlockEnd5Token> for BuilderNodeId {
494    fn from(token: CodeBlockEnd5Token) -> Self {
495        token.node_id
496    }
497}
498///Branded type for Backtick4 terminal
499#[derive(Debug, Clone)]
500pub struct Backtick4Token {
501    pub(super) node_id: BuilderNodeId,
502    pub(super) builder: CstBuilder,
503}
504impl Backtick4Token {
505    /// Consume this token and return its builder
506    pub fn into_builder(self) -> CstBuilder {
507        self.builder
508    }
509}
510impl From<Backtick4Token> for BuilderNodeId {
511    fn from(token: Backtick4Token) -> Self {
512        token.node_id
513    }
514}
515///Branded type for CodeBlockEnd6 terminal
516#[derive(Debug, Clone)]
517pub struct CodeBlockEnd6Token {
518    pub(super) node_id: BuilderNodeId,
519    pub(super) builder: CstBuilder,
520}
521impl CodeBlockEnd6Token {
522    /// Consume this token and return its builder
523    pub fn into_builder(self) -> CstBuilder {
524        self.builder
525    }
526}
527impl From<CodeBlockEnd6Token> for BuilderNodeId {
528    fn from(token: CodeBlockEnd6Token) -> Self {
529        token.node_id
530    }
531}
532///Branded type for Backtick5 terminal
533#[derive(Debug, Clone)]
534pub struct Backtick5Token {
535    pub(super) node_id: BuilderNodeId,
536    pub(super) builder: CstBuilder,
537}
538impl Backtick5Token {
539    /// Consume this token and return its builder
540    pub fn into_builder(self) -> CstBuilder {
541        self.builder
542    }
543}
544impl From<Backtick5Token> for BuilderNodeId {
545    fn from(token: Backtick5Token) -> Self {
546        token.node_id
547    }
548}
549///Branded type for NoBacktick terminal
550#[derive(Debug, Clone)]
551pub struct NoBacktickToken {
552    pub(super) node_id: BuilderNodeId,
553    pub(super) builder: CstBuilder,
554}
555impl NoBacktickToken {
556    /// Consume this token and return its builder
557    pub fn into_builder(self) -> CstBuilder {
558        self.builder
559    }
560}
561impl From<NoBacktickToken> for BuilderNodeId {
562    fn from(token: NoBacktickToken) -> Self {
563        token.node_id
564    }
565}
566///Branded type for LitStr3End terminal
567#[derive(Debug, Clone)]
568pub struct LitStr3EndToken {
569    pub(super) node_id: BuilderNodeId,
570    pub(super) builder: CstBuilder,
571}
572impl LitStr3EndToken {
573    /// Consume this token and return its builder
574    pub fn into_builder(self) -> CstBuilder {
575        self.builder
576    }
577}
578impl From<LitStr3EndToken> for BuilderNodeId {
579    fn from(token: LitStr3EndToken) -> Self {
580        token.node_id
581    }
582}
583///Branded type for LitStr2End terminal
584#[derive(Debug, Clone)]
585pub struct LitStr2EndToken {
586    pub(super) node_id: BuilderNodeId,
587    pub(super) builder: CstBuilder,
588}
589impl LitStr2EndToken {
590    /// Consume this token and return its builder
591    pub fn into_builder(self) -> CstBuilder {
592        self.builder
593    }
594}
595impl From<LitStr2EndToken> for BuilderNodeId {
596    fn from(token: LitStr2EndToken) -> Self {
597        token.node_id
598    }
599}
600///Branded type for LitStr1End terminal
601#[derive(Debug, Clone)]
602pub struct LitStr1EndToken {
603    pub(super) node_id: BuilderNodeId,
604    pub(super) builder: CstBuilder,
605}
606impl LitStr1EndToken {
607    /// Consume this token and return its builder
608    pub fn into_builder(self) -> CstBuilder {
609        self.builder
610    }
611}
612impl From<LitStr1EndToken> for BuilderNodeId {
613    fn from(token: LitStr1EndToken) -> Self {
614        token.node_id
615    }
616}
617///Branded type for SQuote terminal
618#[derive(Debug, Clone)]
619pub struct SQuoteToken {
620    pub(super) node_id: BuilderNodeId,
621    pub(super) builder: CstBuilder,
622}
623impl SQuoteToken {
624    /// Consume this token and return its builder
625    pub fn into_builder(self) -> CstBuilder {
626        self.builder
627    }
628}
629impl From<SQuoteToken> for BuilderNodeId {
630    fn from(token: SQuoteToken) -> Self {
631        token.node_id
632    }
633}
634///Branded type for NoSQuote terminal
635#[derive(Debug, Clone)]
636pub struct NoSQuoteToken {
637    pub(super) node_id: BuilderNodeId,
638    pub(super) builder: CstBuilder,
639}
640impl NoSQuoteToken {
641    /// Consume this token and return its builder
642    pub fn into_builder(self) -> CstBuilder {
643        self.builder
644    }
645}
646impl From<NoSQuoteToken> for BuilderNodeId {
647    fn from(token: NoSQuoteToken) -> Self {
648        token.node_id
649    }
650}
651///Branded type for DelimCodeEnd3 terminal
652#[derive(Debug, Clone)]
653pub struct DelimCodeEnd3Token {
654    pub(super) node_id: BuilderNodeId,
655    pub(super) builder: CstBuilder,
656}
657impl DelimCodeEnd3Token {
658    /// Consume this token and return its builder
659    pub fn into_builder(self) -> CstBuilder {
660        self.builder
661    }
662}
663impl From<DelimCodeEnd3Token> for BuilderNodeId {
664    fn from(token: DelimCodeEnd3Token) -> Self {
665        token.node_id
666    }
667}
668///Branded type for DelimCodeEnd2 terminal
669#[derive(Debug, Clone)]
670pub struct DelimCodeEnd2Token {
671    pub(super) node_id: BuilderNodeId,
672    pub(super) builder: CstBuilder,
673}
674impl DelimCodeEnd2Token {
675    /// Consume this token and return its builder
676    pub fn into_builder(self) -> CstBuilder {
677        self.builder
678    }
679}
680impl From<DelimCodeEnd2Token> for BuilderNodeId {
681    fn from(token: DelimCodeEnd2Token) -> Self {
682        token.node_id
683    }
684}
685///Branded type for DelimCodeEnd1 terminal
686#[derive(Debug, Clone)]
687pub struct DelimCodeEnd1Token {
688    pub(super) node_id: BuilderNodeId,
689    pub(super) builder: CstBuilder,
690}
691impl DelimCodeEnd1Token {
692    /// Consume this token and return its builder
693    pub fn into_builder(self) -> CstBuilder {
694        self.builder
695    }
696}
697impl From<DelimCodeEnd1Token> for BuilderNodeId {
698    fn from(token: DelimCodeEnd1Token) -> Self {
699        token.node_id
700    }
701}
702///Branded type for BacktickDelim terminal
703#[derive(Debug, Clone)]
704pub struct BacktickDelimToken {
705    pub(super) node_id: BuilderNodeId,
706    pub(super) builder: CstBuilder,
707}
708impl BacktickDelimToken {
709    /// Consume this token and return its builder
710    pub fn into_builder(self) -> CstBuilder {
711        self.builder
712    }
713}
714impl From<BacktickDelimToken> for BuilderNodeId {
715    fn from(token: BacktickDelimToken) -> Self {
716        token.node_id
717    }
718}
719///Branded type for GrammarNewline terminal
720#[derive(Debug, Clone)]
721pub struct GrammarNewlineToken {
722    pub(super) node_id: BuilderNodeId,
723    pub(super) builder: CstBuilder,
724}
725impl GrammarNewlineToken {
726    /// Consume this token and return its builder
727    pub fn into_builder(self) -> CstBuilder {
728        self.builder
729    }
730}
731impl From<GrammarNewlineToken> for BuilderNodeId {
732    fn from(token: GrammarNewlineToken) -> Self {
733        token.node_id
734    }
735}
736///Branded type for Ws terminal
737#[derive(Debug, Clone)]
738pub struct WsToken {
739    pub(super) node_id: BuilderNodeId,
740    pub(super) builder: CstBuilder,
741}
742impl WsToken {
743    /// Consume this token and return its builder
744    pub fn into_builder(self) -> CstBuilder {
745        self.builder
746    }
747}
748impl From<WsToken> for BuilderNodeId {
749    fn from(token: WsToken) -> Self {
750        token.node_id
751    }
752}
753///Branded type for At terminal
754#[derive(Debug, Clone)]
755pub struct AtToken {
756    pub(super) node_id: BuilderNodeId,
757    pub(super) builder: CstBuilder,
758}
759impl AtToken {
760    /// Consume this token and return its builder
761    pub fn into_builder(self) -> CstBuilder {
762        self.builder
763    }
764}
765impl From<AtToken> for BuilderNodeId {
766    fn from(token: AtToken) -> Self {
767        token.node_id
768    }
769}
770///Branded type for Dollar terminal
771#[derive(Debug, Clone)]
772pub struct DollarToken {
773    pub(super) node_id: BuilderNodeId,
774    pub(super) builder: CstBuilder,
775}
776impl DollarToken {
777    /// Consume this token and return its builder
778    pub fn into_builder(self) -> CstBuilder {
779        self.builder
780    }
781}
782impl From<DollarToken> for BuilderNodeId {
783    fn from(token: DollarToken) -> Self {
784        token.node_id
785    }
786}
787///Branded type for Dot terminal
788#[derive(Debug, Clone)]
789pub struct DotToken {
790    pub(super) node_id: BuilderNodeId,
791    pub(super) builder: CstBuilder,
792}
793impl DotToken {
794    /// Consume this token and return its builder
795    pub fn into_builder(self) -> CstBuilder {
796        self.builder
797    }
798}
799impl From<DotToken> for BuilderNodeId {
800    fn from(token: DotToken) -> Self {
801        token.node_id
802    }
803}
804///Branded type for LBrace terminal
805#[derive(Debug, Clone)]
806pub struct LBraceToken {
807    pub(super) node_id: BuilderNodeId,
808    pub(super) builder: CstBuilder,
809}
810impl LBraceToken {
811    /// Consume this token and return its builder
812    pub fn into_builder(self) -> CstBuilder {
813        self.builder
814    }
815}
816impl From<LBraceToken> for BuilderNodeId {
817    fn from(token: LBraceToken) -> Self {
818        token.node_id
819    }
820}
821///Branded type for RBrace terminal
822#[derive(Debug, Clone)]
823pub struct RBraceToken {
824    pub(super) node_id: BuilderNodeId,
825    pub(super) builder: CstBuilder,
826}
827impl RBraceToken {
828    /// Consume this token and return its builder
829    pub fn into_builder(self) -> CstBuilder {
830        self.builder
831    }
832}
833impl From<RBraceToken> for BuilderNodeId {
834    fn from(token: RBraceToken) -> Self {
835        token.node_id
836    }
837}
838///Branded type for LBracket terminal
839#[derive(Debug, Clone)]
840pub struct LBracketToken {
841    pub(super) node_id: BuilderNodeId,
842    pub(super) builder: CstBuilder,
843}
844impl LBracketToken {
845    /// Consume this token and return its builder
846    pub fn into_builder(self) -> CstBuilder {
847        self.builder
848    }
849}
850impl From<LBracketToken> for BuilderNodeId {
851    fn from(token: LBracketToken) -> Self {
852        token.node_id
853    }
854}
855///Branded type for RBracket terminal
856#[derive(Debug, Clone)]
857pub struct RBracketToken {
858    pub(super) node_id: BuilderNodeId,
859    pub(super) builder: CstBuilder,
860}
861impl RBracketToken {
862    /// Consume this token and return its builder
863    pub fn into_builder(self) -> CstBuilder {
864        self.builder
865    }
866}
867impl From<RBracketToken> for BuilderNodeId {
868    fn from(token: RBracketToken) -> Self {
869        token.node_id
870    }
871}
872///Branded type for LParen terminal
873#[derive(Debug, Clone)]
874pub struct LParenToken {
875    pub(super) node_id: BuilderNodeId,
876    pub(super) builder: CstBuilder,
877}
878impl LParenToken {
879    /// Consume this token and return its builder
880    pub fn into_builder(self) -> CstBuilder {
881        self.builder
882    }
883}
884impl From<LParenToken> for BuilderNodeId {
885    fn from(token: LParenToken) -> Self {
886        token.node_id
887    }
888}
889///Branded type for RParen terminal
890#[derive(Debug, Clone)]
891pub struct RParenToken {
892    pub(super) node_id: BuilderNodeId,
893    pub(super) builder: CstBuilder,
894}
895impl RParenToken {
896    /// Consume this token and return its builder
897    pub fn into_builder(self) -> CstBuilder {
898        self.builder
899    }
900}
901impl From<RParenToken> for BuilderNodeId {
902    fn from(token: RParenToken) -> Self {
903        token.node_id
904    }
905}
906///Branded type for NewlineBind terminal
907#[derive(Debug, Clone)]
908pub struct NewlineBindToken {
909    pub(super) node_id: BuilderNodeId,
910    pub(super) builder: CstBuilder,
911}
912impl NewlineBindToken {
913    /// Consume this token and return its builder
914    pub fn into_builder(self) -> CstBuilder {
915        self.builder
916    }
917}
918impl From<NewlineBindToken> for BuilderNodeId {
919    fn from(token: NewlineBindToken) -> Self {
920        token.node_id
921    }
922}
923///Branded type for Bind terminal
924#[derive(Debug, Clone)]
925pub struct BindToken {
926    pub(super) node_id: BuilderNodeId,
927    pub(super) builder: CstBuilder,
928}
929impl BindToken {
930    /// Consume this token and return its builder
931    pub fn into_builder(self) -> CstBuilder {
932        self.builder
933    }
934}
935impl From<BindToken> for BuilderNodeId {
936    fn from(token: BindToken) -> Self {
937        token.node_id
938    }
939}
940///Branded type for Comma terminal
941#[derive(Debug, Clone)]
942pub struct CommaToken {
943    pub(super) node_id: BuilderNodeId,
944    pub(super) builder: CstBuilder,
945}
946impl CommaToken {
947    /// Consume this token and return its builder
948    pub fn into_builder(self) -> CstBuilder {
949        self.builder
950    }
951}
952impl From<CommaToken> for BuilderNodeId {
953    fn from(token: CommaToken) -> Self {
954        token.node_id
955    }
956}
957///Branded type for Esc terminal
958#[derive(Debug, Clone)]
959pub struct EscToken {
960    pub(super) node_id: BuilderNodeId,
961    pub(super) builder: CstBuilder,
962}
963impl EscToken {
964    /// Consume this token and return its builder
965    pub fn into_builder(self) -> CstBuilder {
966        self.builder
967    }
968}
969impl From<EscToken> for BuilderNodeId {
970    fn from(token: EscToken) -> Self {
971        token.node_id
972    }
973}
974///Branded type for NewlineTextStart terminal
975#[derive(Debug, Clone)]
976pub struct NewlineTextStartToken {
977    pub(super) node_id: BuilderNodeId,
978    pub(super) builder: CstBuilder,
979}
980impl NewlineTextStartToken {
981    /// Consume this token and return its builder
982    pub fn into_builder(self) -> CstBuilder {
983        self.builder
984    }
985}
986impl From<NewlineTextStartToken> for BuilderNodeId {
987    fn from(token: NewlineTextStartToken) -> Self {
988        token.node_id
989    }
990}
991///Branded type for TextStart terminal
992#[derive(Debug, Clone)]
993pub struct TextStartToken {
994    pub(super) node_id: BuilderNodeId,
995    pub(super) builder: CstBuilder,
996}
997impl TextStartToken {
998    /// Consume this token and return its builder
999    pub fn into_builder(self) -> CstBuilder {
1000        self.builder
1001    }
1002}
1003impl From<TextStartToken> for BuilderNodeId {
1004    fn from(token: TextStartToken) -> Self {
1005        token.node_id
1006    }
1007}
1008///Branded type for Ident terminal
1009#[derive(Debug, Clone)]
1010pub struct IdentToken {
1011    pub(super) node_id: BuilderNodeId,
1012    pub(super) builder: CstBuilder,
1013}
1014impl IdentToken {
1015    /// Consume this token and return its builder
1016    pub fn into_builder(self) -> CstBuilder {
1017        self.builder
1018    }
1019}
1020impl From<IdentToken> for BuilderNodeId {
1021    fn from(token: IdentToken) -> Self {
1022        token.node_id
1023    }
1024}
1025///Branded type for Array non-terminal
1026#[derive(Debug, Clone)]
1027pub struct ArrayNode {
1028    pub(super) node_id: BuilderNodeId,
1029    pub(super) builder: CstBuilder,
1030}
1031impl ArrayNode {
1032    /// Consume this node and return its builder
1033    pub fn into_builder(self) -> CstBuilder {
1034        self.builder
1035    }
1036}
1037impl From<ArrayNode> for BuilderNodeId {
1038    fn from(node: ArrayNode) -> Self {
1039        node.node_id
1040    }
1041}
1042///Branded type for ArrayBegin non-terminal
1043#[derive(Debug, Clone)]
1044pub struct ArrayBeginNode {
1045    pub(super) node_id: BuilderNodeId,
1046    pub(super) builder: CstBuilder,
1047}
1048impl ArrayBeginNode {
1049    /// Consume this node and return its builder
1050    pub fn into_builder(self) -> CstBuilder {
1051        self.builder
1052    }
1053}
1054impl From<ArrayBeginNode> for BuilderNodeId {
1055    fn from(node: ArrayBeginNode) -> Self {
1056        node.node_id
1057    }
1058}
1059///Branded type for ArrayElements non-terminal
1060#[derive(Debug, Clone)]
1061pub struct ArrayElementsNode {
1062    pub(super) node_id: BuilderNodeId,
1063    pub(super) builder: CstBuilder,
1064}
1065impl ArrayElementsNode {
1066    /// Consume this node and return its builder
1067    pub fn into_builder(self) -> CstBuilder {
1068        self.builder
1069    }
1070}
1071impl From<ArrayElementsNode> for BuilderNodeId {
1072    fn from(node: ArrayElementsNode) -> Self {
1073        node.node_id
1074    }
1075}
1076///Branded type for ArrayElementsOpt non-terminal
1077#[derive(Debug, Clone)]
1078pub struct ArrayElementsOptNode {
1079    pub(super) node_id: BuilderNodeId,
1080    pub(super) builder: CstBuilder,
1081}
1082impl ArrayElementsOptNode {
1083    /// Consume this node and return its builder
1084    pub fn into_builder(self) -> CstBuilder {
1085        self.builder
1086    }
1087}
1088impl From<ArrayElementsOptNode> for BuilderNodeId {
1089    fn from(node: ArrayElementsOptNode) -> Self {
1090        node.node_id
1091    }
1092}
1093///Branded type for ArrayElementsTail non-terminal
1094#[derive(Debug, Clone)]
1095pub struct ArrayElementsTailNode {
1096    pub(super) node_id: BuilderNodeId,
1097    pub(super) builder: CstBuilder,
1098}
1099impl ArrayElementsTailNode {
1100    /// Consume this node and return its builder
1101    pub fn into_builder(self) -> CstBuilder {
1102        self.builder
1103    }
1104}
1105impl From<ArrayElementsTailNode> for BuilderNodeId {
1106    fn from(node: ArrayElementsTailNode) -> Self {
1107        node.node_id
1108    }
1109}
1110///Branded type for ArrayElementsTailOpt non-terminal
1111#[derive(Debug, Clone)]
1112pub struct ArrayElementsTailOptNode {
1113    pub(super) node_id: BuilderNodeId,
1114    pub(super) builder: CstBuilder,
1115}
1116impl ArrayElementsTailOptNode {
1117    /// Consume this node and return its builder
1118    pub fn into_builder(self) -> CstBuilder {
1119        self.builder
1120    }
1121}
1122impl From<ArrayElementsTailOptNode> for BuilderNodeId {
1123    fn from(node: ArrayElementsTailOptNode) -> Self {
1124        node.node_id
1125    }
1126}
1127///Branded type for ArrayEnd non-terminal
1128#[derive(Debug, Clone)]
1129pub struct ArrayEndNode {
1130    pub(super) node_id: BuilderNodeId,
1131    pub(super) builder: CstBuilder,
1132}
1133impl ArrayEndNode {
1134    /// Consume this node and return its builder
1135    pub fn into_builder(self) -> CstBuilder {
1136        self.builder
1137    }
1138}
1139impl From<ArrayEndNode> for BuilderNodeId {
1140    fn from(node: ArrayEndNode) -> Self {
1141        node.node_id
1142    }
1143}
1144///Branded type for ArrayMarker non-terminal
1145#[derive(Debug, Clone)]
1146pub struct ArrayMarkerNode {
1147    pub(super) node_id: BuilderNodeId,
1148    pub(super) builder: CstBuilder,
1149}
1150impl ArrayMarkerNode {
1151    /// Consume this node and return its builder
1152    pub fn into_builder(self) -> CstBuilder {
1153        self.builder
1154    }
1155}
1156impl From<ArrayMarkerNode> for BuilderNodeId {
1157    fn from(node: ArrayMarkerNode) -> Self {
1158        node.node_id
1159    }
1160}
1161///Branded type for ArrayMarkerOpt non-terminal
1162#[derive(Debug, Clone)]
1163pub struct ArrayMarkerOptNode {
1164    pub(super) node_id: BuilderNodeId,
1165    pub(super) builder: CstBuilder,
1166}
1167impl ArrayMarkerOptNode {
1168    /// Consume this node and return its builder
1169    pub fn into_builder(self) -> CstBuilder {
1170        self.builder
1171    }
1172}
1173impl From<ArrayMarkerOptNode> for BuilderNodeId {
1174    fn from(node: ArrayMarkerOptNode) -> Self {
1175        node.node_id
1176    }
1177}
1178///Branded type for ArrayOpt non-terminal
1179#[derive(Debug, Clone)]
1180pub struct ArrayOptNode {
1181    pub(super) node_id: BuilderNodeId,
1182    pub(super) builder: CstBuilder,
1183}
1184impl ArrayOptNode {
1185    /// Consume this node and return its builder
1186    pub fn into_builder(self) -> CstBuilder {
1187        self.builder
1188    }
1189}
1190impl From<ArrayOptNode> for BuilderNodeId {
1191    fn from(node: ArrayOptNode) -> Self {
1192        node.node_id
1193    }
1194}
1195///Branded type for At non-terminal
1196#[derive(Debug, Clone)]
1197pub struct AtNode {
1198    pub(super) node_id: BuilderNodeId,
1199    pub(super) builder: CstBuilder,
1200}
1201impl AtNode {
1202    /// Consume this node and return its builder
1203    pub fn into_builder(self) -> CstBuilder {
1204        self.builder
1205    }
1206}
1207impl From<AtNode> for BuilderNodeId {
1208    fn from(node: AtNode) -> Self {
1209        node.node_id
1210    }
1211}
1212///Branded type for Backtick2 non-terminal
1213#[derive(Debug, Clone)]
1214pub struct Backtick2Node {
1215    pub(super) node_id: BuilderNodeId,
1216    pub(super) builder: CstBuilder,
1217}
1218impl Backtick2Node {
1219    /// Consume this node and return its builder
1220    pub fn into_builder(self) -> CstBuilder {
1221        self.builder
1222    }
1223}
1224impl From<Backtick2Node> for BuilderNodeId {
1225    fn from(node: Backtick2Node) -> Self {
1226        node.node_id
1227    }
1228}
1229///Branded type for Backtick3 non-terminal
1230#[derive(Debug, Clone)]
1231pub struct Backtick3Node {
1232    pub(super) node_id: BuilderNodeId,
1233    pub(super) builder: CstBuilder,
1234}
1235impl Backtick3Node {
1236    /// Consume this node and return its builder
1237    pub fn into_builder(self) -> CstBuilder {
1238        self.builder
1239    }
1240}
1241impl From<Backtick3Node> for BuilderNodeId {
1242    fn from(node: Backtick3Node) -> Self {
1243        node.node_id
1244    }
1245}
1246///Branded type for Backtick4 non-terminal
1247#[derive(Debug, Clone)]
1248pub struct Backtick4Node {
1249    pub(super) node_id: BuilderNodeId,
1250    pub(super) builder: CstBuilder,
1251}
1252impl Backtick4Node {
1253    /// Consume this node and return its builder
1254    pub fn into_builder(self) -> CstBuilder {
1255        self.builder
1256    }
1257}
1258impl From<Backtick4Node> for BuilderNodeId {
1259    fn from(node: Backtick4Node) -> Self {
1260        node.node_id
1261    }
1262}
1263///Branded type for Backtick5 non-terminal
1264#[derive(Debug, Clone)]
1265pub struct Backtick5Node {
1266    pub(super) node_id: BuilderNodeId,
1267    pub(super) builder: CstBuilder,
1268}
1269impl Backtick5Node {
1270    /// Consume this node and return its builder
1271    pub fn into_builder(self) -> CstBuilder {
1272        self.builder
1273    }
1274}
1275impl From<Backtick5Node> for BuilderNodeId {
1276    fn from(node: Backtick5Node) -> Self {
1277        node.node_id
1278    }
1279}
1280///Branded type for BacktickDelim non-terminal
1281#[derive(Debug, Clone)]
1282pub struct BacktickDelimNode {
1283    pub(super) node_id: BuilderNodeId,
1284    pub(super) builder: CstBuilder,
1285}
1286impl BacktickDelimNode {
1287    /// Consume this node and return its builder
1288    pub fn into_builder(self) -> CstBuilder {
1289        self.builder
1290    }
1291}
1292impl From<BacktickDelimNode> for BuilderNodeId {
1293    fn from(node: BacktickDelimNode) -> Self {
1294        node.node_id
1295    }
1296}
1297///Branded type for Begin non-terminal
1298#[derive(Debug, Clone)]
1299pub struct BeginNode {
1300    pub(super) node_id: BuilderNodeId,
1301    pub(super) builder: CstBuilder,
1302}
1303impl BeginNode {
1304    /// Consume this node and return its builder
1305    pub fn into_builder(self) -> CstBuilder {
1306        self.builder
1307    }
1308}
1309impl From<BeginNode> for BuilderNodeId {
1310    fn from(node: BeginNode) -> Self {
1311        node.node_id
1312    }
1313}
1314///Branded type for Bind non-terminal
1315#[derive(Debug, Clone)]
1316pub struct BindNode {
1317    pub(super) node_id: BuilderNodeId,
1318    pub(super) builder: CstBuilder,
1319}
1320impl BindNode {
1321    /// Consume this node and return its builder
1322    pub fn into_builder(self) -> CstBuilder {
1323        self.builder
1324    }
1325}
1326impl From<BindNode> for BuilderNodeId {
1327    fn from(node: BindNode) -> Self {
1328        node.node_id
1329    }
1330}
1331///Branded type for Binding non-terminal
1332#[derive(Debug, Clone)]
1333pub struct BindingNode {
1334    pub(super) node_id: BuilderNodeId,
1335    pub(super) builder: CstBuilder,
1336}
1337impl BindingNode {
1338    /// Consume this node and return its builder
1339    pub fn into_builder(self) -> CstBuilder {
1340        self.builder
1341    }
1342}
1343impl From<BindingNode> for BuilderNodeId {
1344    fn from(node: BindingNode) -> Self {
1345        node.node_id
1346    }
1347}
1348///Branded type for BindingRhs non-terminal
1349#[derive(Debug, Clone)]
1350pub struct BindingRhsNode {
1351    pub(super) node_id: BuilderNodeId,
1352    pub(super) builder: CstBuilder,
1353}
1354impl BindingRhsNode {
1355    /// Consume this node and return its builder
1356    pub fn into_builder(self) -> CstBuilder {
1357        self.builder
1358    }
1359}
1360impl From<BindingRhsNode> for BuilderNodeId {
1361    fn from(node: BindingRhsNode) -> Self {
1362        node.node_id
1363    }
1364}
1365///Branded type for BlockBody non-terminal
1366#[derive(Debug, Clone)]
1367pub struct BlockBodyNode {
1368    pub(super) node_id: BuilderNodeId,
1369    pub(super) builder: CstBuilder,
1370}
1371impl BlockBodyNode {
1372    /// Consume this node and return its builder
1373    pub fn into_builder(self) -> CstBuilder {
1374        self.builder
1375    }
1376}
1377impl From<BlockBodyNode> for BuilderNodeId {
1378    fn from(node: BlockBodyNode) -> Self {
1379        node.node_id
1380    }
1381}
1382///Branded type for Boolean non-terminal
1383#[derive(Debug, Clone)]
1384pub struct BooleanNode {
1385    pub(super) node_id: BuilderNodeId,
1386    pub(super) builder: CstBuilder,
1387}
1388impl BooleanNode {
1389    /// Consume this node and return its builder
1390    pub fn into_builder(self) -> CstBuilder {
1391        self.builder
1392    }
1393}
1394impl From<BooleanNode> for BuilderNodeId {
1395    fn from(node: BooleanNode) -> Self {
1396        node.node_id
1397    }
1398}
1399///Branded type for CodeBlock non-terminal
1400#[derive(Debug, Clone)]
1401pub struct CodeBlockNode {
1402    pub(super) node_id: BuilderNodeId,
1403    pub(super) builder: CstBuilder,
1404}
1405impl CodeBlockNode {
1406    /// Consume this node and return its builder
1407    pub fn into_builder(self) -> CstBuilder {
1408        self.builder
1409    }
1410}
1411impl From<CodeBlockNode> for BuilderNodeId {
1412    fn from(node: CodeBlockNode) -> Self {
1413        node.node_id
1414    }
1415}
1416///Branded type for CodeBlock3 non-terminal
1417#[derive(Debug, Clone)]
1418pub struct CodeBlock3Node {
1419    pub(super) node_id: BuilderNodeId,
1420    pub(super) builder: CstBuilder,
1421}
1422impl CodeBlock3Node {
1423    /// Consume this node and return its builder
1424    pub fn into_builder(self) -> CstBuilder {
1425        self.builder
1426    }
1427}
1428impl From<CodeBlock3Node> for BuilderNodeId {
1429    fn from(node: CodeBlock3Node) -> Self {
1430        node.node_id
1431    }
1432}
1433///Branded type for CodeBlock3List non-terminal
1434#[derive(Debug, Clone)]
1435pub struct CodeBlock3ListNode {
1436    pub(super) node_id: BuilderNodeId,
1437    pub(super) builder: CstBuilder,
1438}
1439impl CodeBlock3ListNode {
1440    /// Consume this node and return its builder
1441    pub fn into_builder(self) -> CstBuilder {
1442        self.builder
1443    }
1444}
1445impl From<CodeBlock3ListNode> for BuilderNodeId {
1446    fn from(node: CodeBlock3ListNode) -> Self {
1447        node.node_id
1448    }
1449}
1450///Branded type for CodeBlock3ListGroup non-terminal
1451#[derive(Debug, Clone)]
1452pub struct CodeBlock3ListGroupNode {
1453    pub(super) node_id: BuilderNodeId,
1454    pub(super) builder: CstBuilder,
1455}
1456impl CodeBlock3ListGroupNode {
1457    /// Consume this node and return its builder
1458    pub fn into_builder(self) -> CstBuilder {
1459        self.builder
1460    }
1461}
1462impl From<CodeBlock3ListGroupNode> for BuilderNodeId {
1463    fn from(node: CodeBlock3ListGroupNode) -> Self {
1464        node.node_id
1465    }
1466}
1467///Branded type for CodeBlock4 non-terminal
1468#[derive(Debug, Clone)]
1469pub struct CodeBlock4Node {
1470    pub(super) node_id: BuilderNodeId,
1471    pub(super) builder: CstBuilder,
1472}
1473impl CodeBlock4Node {
1474    /// Consume this node and return its builder
1475    pub fn into_builder(self) -> CstBuilder {
1476        self.builder
1477    }
1478}
1479impl From<CodeBlock4Node> for BuilderNodeId {
1480    fn from(node: CodeBlock4Node) -> Self {
1481        node.node_id
1482    }
1483}
1484///Branded type for CodeBlock4List non-terminal
1485#[derive(Debug, Clone)]
1486pub struct CodeBlock4ListNode {
1487    pub(super) node_id: BuilderNodeId,
1488    pub(super) builder: CstBuilder,
1489}
1490impl CodeBlock4ListNode {
1491    /// Consume this node and return its builder
1492    pub fn into_builder(self) -> CstBuilder {
1493        self.builder
1494    }
1495}
1496impl From<CodeBlock4ListNode> for BuilderNodeId {
1497    fn from(node: CodeBlock4ListNode) -> Self {
1498        node.node_id
1499    }
1500}
1501///Branded type for CodeBlock4ListGroup non-terminal
1502#[derive(Debug, Clone)]
1503pub struct CodeBlock4ListGroupNode {
1504    pub(super) node_id: BuilderNodeId,
1505    pub(super) builder: CstBuilder,
1506}
1507impl CodeBlock4ListGroupNode {
1508    /// Consume this node and return its builder
1509    pub fn into_builder(self) -> CstBuilder {
1510        self.builder
1511    }
1512}
1513impl From<CodeBlock4ListGroupNode> for BuilderNodeId {
1514    fn from(node: CodeBlock4ListGroupNode) -> Self {
1515        node.node_id
1516    }
1517}
1518///Branded type for CodeBlock5 non-terminal
1519#[derive(Debug, Clone)]
1520pub struct CodeBlock5Node {
1521    pub(super) node_id: BuilderNodeId,
1522    pub(super) builder: CstBuilder,
1523}
1524impl CodeBlock5Node {
1525    /// Consume this node and return its builder
1526    pub fn into_builder(self) -> CstBuilder {
1527        self.builder
1528    }
1529}
1530impl From<CodeBlock5Node> for BuilderNodeId {
1531    fn from(node: CodeBlock5Node) -> Self {
1532        node.node_id
1533    }
1534}
1535///Branded type for CodeBlock5List non-terminal
1536#[derive(Debug, Clone)]
1537pub struct CodeBlock5ListNode {
1538    pub(super) node_id: BuilderNodeId,
1539    pub(super) builder: CstBuilder,
1540}
1541impl CodeBlock5ListNode {
1542    /// Consume this node and return its builder
1543    pub fn into_builder(self) -> CstBuilder {
1544        self.builder
1545    }
1546}
1547impl From<CodeBlock5ListNode> for BuilderNodeId {
1548    fn from(node: CodeBlock5ListNode) -> Self {
1549        node.node_id
1550    }
1551}
1552///Branded type for CodeBlock5ListGroup non-terminal
1553#[derive(Debug, Clone)]
1554pub struct CodeBlock5ListGroupNode {
1555    pub(super) node_id: BuilderNodeId,
1556    pub(super) builder: CstBuilder,
1557}
1558impl CodeBlock5ListGroupNode {
1559    /// Consume this node and return its builder
1560    pub fn into_builder(self) -> CstBuilder {
1561        self.builder
1562    }
1563}
1564impl From<CodeBlock5ListGroupNode> for BuilderNodeId {
1565    fn from(node: CodeBlock5ListGroupNode) -> Self {
1566        node.node_id
1567    }
1568}
1569///Branded type for CodeBlock6 non-terminal
1570#[derive(Debug, Clone)]
1571pub struct CodeBlock6Node {
1572    pub(super) node_id: BuilderNodeId,
1573    pub(super) builder: CstBuilder,
1574}
1575impl CodeBlock6Node {
1576    /// Consume this node and return its builder
1577    pub fn into_builder(self) -> CstBuilder {
1578        self.builder
1579    }
1580}
1581impl From<CodeBlock6Node> for BuilderNodeId {
1582    fn from(node: CodeBlock6Node) -> Self {
1583        node.node_id
1584    }
1585}
1586///Branded type for CodeBlock6List non-terminal
1587#[derive(Debug, Clone)]
1588pub struct CodeBlock6ListNode {
1589    pub(super) node_id: BuilderNodeId,
1590    pub(super) builder: CstBuilder,
1591}
1592impl CodeBlock6ListNode {
1593    /// Consume this node and return its builder
1594    pub fn into_builder(self) -> CstBuilder {
1595        self.builder
1596    }
1597}
1598impl From<CodeBlock6ListNode> for BuilderNodeId {
1599    fn from(node: CodeBlock6ListNode) -> Self {
1600        node.node_id
1601    }
1602}
1603///Branded type for CodeBlock6ListGroup non-terminal
1604#[derive(Debug, Clone)]
1605pub struct CodeBlock6ListGroupNode {
1606    pub(super) node_id: BuilderNodeId,
1607    pub(super) builder: CstBuilder,
1608}
1609impl CodeBlock6ListGroupNode {
1610    /// Consume this node and return its builder
1611    pub fn into_builder(self) -> CstBuilder {
1612        self.builder
1613    }
1614}
1615impl From<CodeBlock6ListGroupNode> for BuilderNodeId {
1616    fn from(node: CodeBlock6ListGroupNode) -> Self {
1617        node.node_id
1618    }
1619}
1620///Branded type for CodeBlockEnd3 non-terminal
1621#[derive(Debug, Clone)]
1622pub struct CodeBlockEnd3Node {
1623    pub(super) node_id: BuilderNodeId,
1624    pub(super) builder: CstBuilder,
1625}
1626impl CodeBlockEnd3Node {
1627    /// Consume this node and return its builder
1628    pub fn into_builder(self) -> CstBuilder {
1629        self.builder
1630    }
1631}
1632impl From<CodeBlockEnd3Node> for BuilderNodeId {
1633    fn from(node: CodeBlockEnd3Node) -> Self {
1634        node.node_id
1635    }
1636}
1637///Branded type for CodeBlockEnd4 non-terminal
1638#[derive(Debug, Clone)]
1639pub struct CodeBlockEnd4Node {
1640    pub(super) node_id: BuilderNodeId,
1641    pub(super) builder: CstBuilder,
1642}
1643impl CodeBlockEnd4Node {
1644    /// Consume this node and return its builder
1645    pub fn into_builder(self) -> CstBuilder {
1646        self.builder
1647    }
1648}
1649impl From<CodeBlockEnd4Node> for BuilderNodeId {
1650    fn from(node: CodeBlockEnd4Node) -> Self {
1651        node.node_id
1652    }
1653}
1654///Branded type for CodeBlockEnd5 non-terminal
1655#[derive(Debug, Clone)]
1656pub struct CodeBlockEnd5Node {
1657    pub(super) node_id: BuilderNodeId,
1658    pub(super) builder: CstBuilder,
1659}
1660impl CodeBlockEnd5Node {
1661    /// Consume this node and return its builder
1662    pub fn into_builder(self) -> CstBuilder {
1663        self.builder
1664    }
1665}
1666impl From<CodeBlockEnd5Node> for BuilderNodeId {
1667    fn from(node: CodeBlockEnd5Node) -> Self {
1668        node.node_id
1669    }
1670}
1671///Branded type for CodeBlockEnd6 non-terminal
1672#[derive(Debug, Clone)]
1673pub struct CodeBlockEnd6Node {
1674    pub(super) node_id: BuilderNodeId,
1675    pub(super) builder: CstBuilder,
1676}
1677impl CodeBlockEnd6Node {
1678    /// Consume this node and return its builder
1679    pub fn into_builder(self) -> CstBuilder {
1680        self.builder
1681    }
1682}
1683impl From<CodeBlockEnd6Node> for BuilderNodeId {
1684    fn from(node: CodeBlockEnd6Node) -> Self {
1685        node.node_id
1686    }
1687}
1688///Branded type for CodeBlockStart3 non-terminal
1689#[derive(Debug, Clone)]
1690pub struct CodeBlockStart3Node {
1691    pub(super) node_id: BuilderNodeId,
1692    pub(super) builder: CstBuilder,
1693}
1694impl CodeBlockStart3Node {
1695    /// Consume this node and return its builder
1696    pub fn into_builder(self) -> CstBuilder {
1697        self.builder
1698    }
1699}
1700impl From<CodeBlockStart3Node> for BuilderNodeId {
1701    fn from(node: CodeBlockStart3Node) -> Self {
1702        node.node_id
1703    }
1704}
1705///Branded type for CodeBlockStart4 non-terminal
1706#[derive(Debug, Clone)]
1707pub struct CodeBlockStart4Node {
1708    pub(super) node_id: BuilderNodeId,
1709    pub(super) builder: CstBuilder,
1710}
1711impl CodeBlockStart4Node {
1712    /// Consume this node and return its builder
1713    pub fn into_builder(self) -> CstBuilder {
1714        self.builder
1715    }
1716}
1717impl From<CodeBlockStart4Node> for BuilderNodeId {
1718    fn from(node: CodeBlockStart4Node) -> Self {
1719        node.node_id
1720    }
1721}
1722///Branded type for CodeBlockStart5 non-terminal
1723#[derive(Debug, Clone)]
1724pub struct CodeBlockStart5Node {
1725    pub(super) node_id: BuilderNodeId,
1726    pub(super) builder: CstBuilder,
1727}
1728impl CodeBlockStart5Node {
1729    /// Consume this node and return its builder
1730    pub fn into_builder(self) -> CstBuilder {
1731        self.builder
1732    }
1733}
1734impl From<CodeBlockStart5Node> for BuilderNodeId {
1735    fn from(node: CodeBlockStart5Node) -> Self {
1736        node.node_id
1737    }
1738}
1739///Branded type for CodeBlockStart6 non-terminal
1740#[derive(Debug, Clone)]
1741pub struct CodeBlockStart6Node {
1742    pub(super) node_id: BuilderNodeId,
1743    pub(super) builder: CstBuilder,
1744}
1745impl CodeBlockStart6Node {
1746    /// Consume this node and return its builder
1747    pub fn into_builder(self) -> CstBuilder {
1748        self.builder
1749    }
1750}
1751impl From<CodeBlockStart6Node> for BuilderNodeId {
1752    fn from(node: CodeBlockStart6Node) -> Self {
1753        node.node_id
1754    }
1755}
1756///Branded type for Comma non-terminal
1757#[derive(Debug, Clone)]
1758pub struct CommaNode {
1759    pub(super) node_id: BuilderNodeId,
1760    pub(super) builder: CstBuilder,
1761}
1762impl CommaNode {
1763    /// Consume this node and return its builder
1764    pub fn into_builder(self) -> CstBuilder {
1765        self.builder
1766    }
1767}
1768impl From<CommaNode> for BuilderNodeId {
1769    fn from(node: CommaNode) -> Self {
1770        node.node_id
1771    }
1772}
1773///Branded type for Continue non-terminal
1774#[derive(Debug, Clone)]
1775pub struct ContinueNode {
1776    pub(super) node_id: BuilderNodeId,
1777    pub(super) builder: CstBuilder,
1778}
1779impl ContinueNode {
1780    /// Consume this node and return its builder
1781    pub fn into_builder(self) -> CstBuilder {
1782        self.builder
1783    }
1784}
1785impl From<ContinueNode> for BuilderNodeId {
1786    fn from(node: ContinueNode) -> Self {
1787        node.node_id
1788    }
1789}
1790///Branded type for DelimCode non-terminal
1791#[derive(Debug, Clone)]
1792pub struct DelimCodeNode {
1793    pub(super) node_id: BuilderNodeId,
1794    pub(super) builder: CstBuilder,
1795}
1796impl DelimCodeNode {
1797    /// Consume this node and return its builder
1798    pub fn into_builder(self) -> CstBuilder {
1799        self.builder
1800    }
1801}
1802impl From<DelimCodeNode> for BuilderNodeId {
1803    fn from(node: DelimCodeNode) -> Self {
1804        node.node_id
1805    }
1806}
1807///Branded type for DelimCode1 non-terminal
1808#[derive(Debug, Clone)]
1809pub struct DelimCode1Node {
1810    pub(super) node_id: BuilderNodeId,
1811    pub(super) builder: CstBuilder,
1812}
1813impl DelimCode1Node {
1814    /// Consume this node and return its builder
1815    pub fn into_builder(self) -> CstBuilder {
1816        self.builder
1817    }
1818}
1819impl From<DelimCode1Node> for BuilderNodeId {
1820    fn from(node: DelimCode1Node) -> Self {
1821        node.node_id
1822    }
1823}
1824///Branded type for DelimCode1List non-terminal
1825#[derive(Debug, Clone)]
1826pub struct DelimCode1ListNode {
1827    pub(super) node_id: BuilderNodeId,
1828    pub(super) builder: CstBuilder,
1829}
1830impl DelimCode1ListNode {
1831    /// Consume this node and return its builder
1832    pub fn into_builder(self) -> CstBuilder {
1833        self.builder
1834    }
1835}
1836impl From<DelimCode1ListNode> for BuilderNodeId {
1837    fn from(node: DelimCode1ListNode) -> Self {
1838        node.node_id
1839    }
1840}
1841///Branded type for DelimCode1ListGroup non-terminal
1842#[derive(Debug, Clone)]
1843pub struct DelimCode1ListGroupNode {
1844    pub(super) node_id: BuilderNodeId,
1845    pub(super) builder: CstBuilder,
1846}
1847impl DelimCode1ListGroupNode {
1848    /// Consume this node and return its builder
1849    pub fn into_builder(self) -> CstBuilder {
1850        self.builder
1851    }
1852}
1853impl From<DelimCode1ListGroupNode> for BuilderNodeId {
1854    fn from(node: DelimCode1ListGroupNode) -> Self {
1855        node.node_id
1856    }
1857}
1858///Branded type for DelimCode2 non-terminal
1859#[derive(Debug, Clone)]
1860pub struct DelimCode2Node {
1861    pub(super) node_id: BuilderNodeId,
1862    pub(super) builder: CstBuilder,
1863}
1864impl DelimCode2Node {
1865    /// Consume this node and return its builder
1866    pub fn into_builder(self) -> CstBuilder {
1867        self.builder
1868    }
1869}
1870impl From<DelimCode2Node> for BuilderNodeId {
1871    fn from(node: DelimCode2Node) -> Self {
1872        node.node_id
1873    }
1874}
1875///Branded type for DelimCode2List non-terminal
1876#[derive(Debug, Clone)]
1877pub struct DelimCode2ListNode {
1878    pub(super) node_id: BuilderNodeId,
1879    pub(super) builder: CstBuilder,
1880}
1881impl DelimCode2ListNode {
1882    /// Consume this node and return its builder
1883    pub fn into_builder(self) -> CstBuilder {
1884        self.builder
1885    }
1886}
1887impl From<DelimCode2ListNode> for BuilderNodeId {
1888    fn from(node: DelimCode2ListNode) -> Self {
1889        node.node_id
1890    }
1891}
1892///Branded type for DelimCode2ListGroup non-terminal
1893#[derive(Debug, Clone)]
1894pub struct DelimCode2ListGroupNode {
1895    pub(super) node_id: BuilderNodeId,
1896    pub(super) builder: CstBuilder,
1897}
1898impl DelimCode2ListGroupNode {
1899    /// Consume this node and return its builder
1900    pub fn into_builder(self) -> CstBuilder {
1901        self.builder
1902    }
1903}
1904impl From<DelimCode2ListGroupNode> for BuilderNodeId {
1905    fn from(node: DelimCode2ListGroupNode) -> Self {
1906        node.node_id
1907    }
1908}
1909///Branded type for DelimCode3 non-terminal
1910#[derive(Debug, Clone)]
1911pub struct DelimCode3Node {
1912    pub(super) node_id: BuilderNodeId,
1913    pub(super) builder: CstBuilder,
1914}
1915impl DelimCode3Node {
1916    /// Consume this node and return its builder
1917    pub fn into_builder(self) -> CstBuilder {
1918        self.builder
1919    }
1920}
1921impl From<DelimCode3Node> for BuilderNodeId {
1922    fn from(node: DelimCode3Node) -> Self {
1923        node.node_id
1924    }
1925}
1926///Branded type for DelimCode3List non-terminal
1927#[derive(Debug, Clone)]
1928pub struct DelimCode3ListNode {
1929    pub(super) node_id: BuilderNodeId,
1930    pub(super) builder: CstBuilder,
1931}
1932impl DelimCode3ListNode {
1933    /// Consume this node and return its builder
1934    pub fn into_builder(self) -> CstBuilder {
1935        self.builder
1936    }
1937}
1938impl From<DelimCode3ListNode> for BuilderNodeId {
1939    fn from(node: DelimCode3ListNode) -> Self {
1940        node.node_id
1941    }
1942}
1943///Branded type for DelimCode3ListGroup non-terminal
1944#[derive(Debug, Clone)]
1945pub struct DelimCode3ListGroupNode {
1946    pub(super) node_id: BuilderNodeId,
1947    pub(super) builder: CstBuilder,
1948}
1949impl DelimCode3ListGroupNode {
1950    /// Consume this node and return its builder
1951    pub fn into_builder(self) -> CstBuilder {
1952        self.builder
1953    }
1954}
1955impl From<DelimCode3ListGroupNode> for BuilderNodeId {
1956    fn from(node: DelimCode3ListGroupNode) -> Self {
1957        node.node_id
1958    }
1959}
1960///Branded type for DelimCodeEnd1 non-terminal
1961#[derive(Debug, Clone)]
1962pub struct DelimCodeEnd1Node {
1963    pub(super) node_id: BuilderNodeId,
1964    pub(super) builder: CstBuilder,
1965}
1966impl DelimCodeEnd1Node {
1967    /// Consume this node and return its builder
1968    pub fn into_builder(self) -> CstBuilder {
1969        self.builder
1970    }
1971}
1972impl From<DelimCodeEnd1Node> for BuilderNodeId {
1973    fn from(node: DelimCodeEnd1Node) -> Self {
1974        node.node_id
1975    }
1976}
1977///Branded type for DelimCodeEnd2 non-terminal
1978#[derive(Debug, Clone)]
1979pub struct DelimCodeEnd2Node {
1980    pub(super) node_id: BuilderNodeId,
1981    pub(super) builder: CstBuilder,
1982}
1983impl DelimCodeEnd2Node {
1984    /// Consume this node and return its builder
1985    pub fn into_builder(self) -> CstBuilder {
1986        self.builder
1987    }
1988}
1989impl From<DelimCodeEnd2Node> for BuilderNodeId {
1990    fn from(node: DelimCodeEnd2Node) -> Self {
1991        node.node_id
1992    }
1993}
1994///Branded type for DelimCodeEnd3 non-terminal
1995#[derive(Debug, Clone)]
1996pub struct DelimCodeEnd3Node {
1997    pub(super) node_id: BuilderNodeId,
1998    pub(super) builder: CstBuilder,
1999}
2000impl DelimCodeEnd3Node {
2001    /// Consume this node and return its builder
2002    pub fn into_builder(self) -> CstBuilder {
2003        self.builder
2004    }
2005}
2006impl From<DelimCodeEnd3Node> for BuilderNodeId {
2007    fn from(node: DelimCodeEnd3Node) -> Self {
2008        node.node_id
2009    }
2010}
2011///Branded type for DelimCodeStart1 non-terminal
2012#[derive(Debug, Clone)]
2013pub struct DelimCodeStart1Node {
2014    pub(super) node_id: BuilderNodeId,
2015    pub(super) builder: CstBuilder,
2016}
2017impl DelimCodeStart1Node {
2018    /// Consume this node and return its builder
2019    pub fn into_builder(self) -> CstBuilder {
2020        self.builder
2021    }
2022}
2023impl From<DelimCodeStart1Node> for BuilderNodeId {
2024    fn from(node: DelimCodeStart1Node) -> Self {
2025        node.node_id
2026    }
2027}
2028///Branded type for DelimCodeStart2 non-terminal
2029#[derive(Debug, Clone)]
2030pub struct DelimCodeStart2Node {
2031    pub(super) node_id: BuilderNodeId,
2032    pub(super) builder: CstBuilder,
2033}
2034impl DelimCodeStart2Node {
2035    /// Consume this node and return its builder
2036    pub fn into_builder(self) -> CstBuilder {
2037        self.builder
2038    }
2039}
2040impl From<DelimCodeStart2Node> for BuilderNodeId {
2041    fn from(node: DelimCodeStart2Node) -> Self {
2042        node.node_id
2043    }
2044}
2045///Branded type for DelimCodeStart3 non-terminal
2046#[derive(Debug, Clone)]
2047pub struct DelimCodeStart3Node {
2048    pub(super) node_id: BuilderNodeId,
2049    pub(super) builder: CstBuilder,
2050}
2051impl DelimCodeStart3Node {
2052    /// Consume this node and return its builder
2053    pub fn into_builder(self) -> CstBuilder {
2054        self.builder
2055    }
2056}
2057impl From<DelimCodeStart3Node> for BuilderNodeId {
2058    fn from(node: DelimCodeStart3Node) -> Self {
2059        node.node_id
2060    }
2061}
2062///Branded type for Dot non-terminal
2063#[derive(Debug, Clone)]
2064pub struct DotNode {
2065    pub(super) node_id: BuilderNodeId,
2066    pub(super) builder: CstBuilder,
2067}
2068impl DotNode {
2069    /// Consume this node and return its builder
2070    pub fn into_builder(self) -> CstBuilder {
2071        self.builder
2072    }
2073}
2074impl From<DotNode> for BuilderNodeId {
2075    fn from(node: DotNode) -> Self {
2076        node.node_id
2077    }
2078}
2079///Branded type for DotKey non-terminal
2080#[derive(Debug, Clone)]
2081pub struct DotKeyNode {
2082    pub(super) node_id: BuilderNodeId,
2083    pub(super) builder: CstBuilder,
2084}
2085impl DotKeyNode {
2086    /// Consume this node and return its builder
2087    pub fn into_builder(self) -> CstBuilder {
2088        self.builder
2089    }
2090}
2091impl From<DotKeyNode> for BuilderNodeId {
2092    fn from(node: DotKeyNode) -> Self {
2093        node.node_id
2094    }
2095}
2096///Branded type for End non-terminal
2097#[derive(Debug, Clone)]
2098pub struct EndNode {
2099    pub(super) node_id: BuilderNodeId,
2100    pub(super) builder: CstBuilder,
2101}
2102impl EndNode {
2103    /// Consume this node and return its builder
2104    pub fn into_builder(self) -> CstBuilder {
2105        self.builder
2106    }
2107}
2108impl From<EndNode> for BuilderNodeId {
2109    fn from(node: EndNode) -> Self {
2110        node.node_id
2111    }
2112}
2113///Branded type for Eure non-terminal
2114#[derive(Debug, Clone)]
2115pub struct EureNode {
2116    pub(super) node_id: BuilderNodeId,
2117    pub(super) builder: CstBuilder,
2118}
2119impl EureNode {
2120    /// Consume this node and return its builder
2121    pub fn into_builder(self) -> CstBuilder {
2122        self.builder
2123    }
2124}
2125impl From<EureNode> for BuilderNodeId {
2126    fn from(node: EureNode) -> Self {
2127        node.node_id
2128    }
2129}
2130///Branded type for EureBindings non-terminal
2131#[derive(Debug, Clone)]
2132pub struct EureBindingsNode {
2133    pub(super) node_id: BuilderNodeId,
2134    pub(super) builder: CstBuilder,
2135}
2136impl EureBindingsNode {
2137    /// Consume this node and return its builder
2138    pub fn into_builder(self) -> CstBuilder {
2139        self.builder
2140    }
2141}
2142impl From<EureBindingsNode> for BuilderNodeId {
2143    fn from(node: EureBindingsNode) -> Self {
2144        node.node_id
2145    }
2146}
2147///Branded type for EureSections non-terminal
2148#[derive(Debug, Clone)]
2149pub struct EureSectionsNode {
2150    pub(super) node_id: BuilderNodeId,
2151    pub(super) builder: CstBuilder,
2152}
2153impl EureSectionsNode {
2154    /// Consume this node and return its builder
2155    pub fn into_builder(self) -> CstBuilder {
2156        self.builder
2157    }
2158}
2159impl From<EureSectionsNode> for BuilderNodeId {
2160    fn from(node: EureSectionsNode) -> Self {
2161        node.node_id
2162    }
2163}
2164///Branded type for EureOpt non-terminal
2165#[derive(Debug, Clone)]
2166pub struct EureOptNode {
2167    pub(super) node_id: BuilderNodeId,
2168    pub(super) builder: CstBuilder,
2169}
2170impl EureOptNode {
2171    /// Consume this node and return its builder
2172    pub fn into_builder(self) -> CstBuilder {
2173        self.builder
2174    }
2175}
2176impl From<EureOptNode> for BuilderNodeId {
2177    fn from(node: EureOptNode) -> Self {
2178        node.node_id
2179    }
2180}
2181///Branded type for Ext non-terminal
2182#[derive(Debug, Clone)]
2183pub struct ExtNode {
2184    pub(super) node_id: BuilderNodeId,
2185    pub(super) builder: CstBuilder,
2186}
2187impl ExtNode {
2188    /// Consume this node and return its builder
2189    pub fn into_builder(self) -> CstBuilder {
2190        self.builder
2191    }
2192}
2193impl From<ExtNode> for BuilderNodeId {
2194    fn from(node: ExtNode) -> Self {
2195        node.node_id
2196    }
2197}
2198///Branded type for ExtensionNameSpace non-terminal
2199#[derive(Debug, Clone)]
2200pub struct ExtensionNameSpaceNode {
2201    pub(super) node_id: BuilderNodeId,
2202    pub(super) builder: CstBuilder,
2203}
2204impl ExtensionNameSpaceNode {
2205    /// Consume this node and return its builder
2206    pub fn into_builder(self) -> CstBuilder {
2207        self.builder
2208    }
2209}
2210impl From<ExtensionNameSpaceNode> for BuilderNodeId {
2211    fn from(node: ExtensionNameSpaceNode) -> Self {
2212        node.node_id
2213    }
2214}
2215///Branded type for False non-terminal
2216#[derive(Debug, Clone)]
2217pub struct FalseNode {
2218    pub(super) node_id: BuilderNodeId,
2219    pub(super) builder: CstBuilder,
2220}
2221impl FalseNode {
2222    /// Consume this node and return its builder
2223    pub fn into_builder(self) -> CstBuilder {
2224        self.builder
2225    }
2226}
2227impl From<FalseNode> for BuilderNodeId {
2228    fn from(node: FalseNode) -> Self {
2229        node.node_id
2230    }
2231}
2232///Branded type for FirstKey non-terminal
2233#[derive(Debug, Clone)]
2234pub struct FirstKeyNode {
2235    pub(super) node_id: BuilderNodeId,
2236    pub(super) builder: CstBuilder,
2237}
2238impl FirstKeyNode {
2239    /// Consume this node and return its builder
2240    pub fn into_builder(self) -> CstBuilder {
2241        self.builder
2242    }
2243}
2244impl From<FirstKeyNode> for BuilderNodeId {
2245    fn from(node: FirstKeyNode) -> Self {
2246        node.node_id
2247    }
2248}
2249///Branded type for FlatBody non-terminal
2250#[derive(Debug, Clone)]
2251pub struct FlatBodyNode {
2252    pub(super) node_id: BuilderNodeId,
2253    pub(super) builder: CstBuilder,
2254}
2255impl FlatBodyNode {
2256    /// Consume this node and return its builder
2257    pub fn into_builder(self) -> CstBuilder {
2258        self.builder
2259    }
2260}
2261impl From<FlatBodyNode> for BuilderNodeId {
2262    fn from(node: FlatBodyNode) -> Self {
2263        node.node_id
2264    }
2265}
2266///Branded type for FlatBodyList non-terminal
2267#[derive(Debug, Clone)]
2268pub struct FlatBodyListNode {
2269    pub(super) node_id: BuilderNodeId,
2270    pub(super) builder: CstBuilder,
2271}
2272impl FlatBodyListNode {
2273    /// Consume this node and return its builder
2274    pub fn into_builder(self) -> CstBuilder {
2275        self.builder
2276    }
2277}
2278impl From<FlatBodyListNode> for BuilderNodeId {
2279    fn from(node: FlatBodyListNode) -> Self {
2280        node.node_id
2281    }
2282}
2283///Branded type for FlatRootBinding non-terminal
2284#[derive(Debug, Clone)]
2285pub struct FlatRootBindingNode {
2286    pub(super) node_id: BuilderNodeId,
2287    pub(super) builder: CstBuilder,
2288}
2289impl FlatRootBindingNode {
2290    /// Consume this node and return its builder
2291    pub fn into_builder(self) -> CstBuilder {
2292        self.builder
2293    }
2294}
2295impl From<FlatRootBindingNode> for BuilderNodeId {
2296    fn from(node: FlatRootBindingNode) -> Self {
2297        node.node_id
2298    }
2299}
2300///Branded type for Float non-terminal
2301#[derive(Debug, Clone)]
2302pub struct FloatNode {
2303    pub(super) node_id: BuilderNodeId,
2304    pub(super) builder: CstBuilder,
2305}
2306impl FloatNode {
2307    /// Consume this node and return its builder
2308    pub fn into_builder(self) -> CstBuilder {
2309        self.builder
2310    }
2311}
2312impl From<FloatNode> for BuilderNodeId {
2313    fn from(node: FloatNode) -> Self {
2314        node.node_id
2315    }
2316}
2317///Branded type for GrammarNewline non-terminal
2318#[derive(Debug, Clone)]
2319pub struct GrammarNewlineNode {
2320    pub(super) node_id: BuilderNodeId,
2321    pub(super) builder: CstBuilder,
2322}
2323impl GrammarNewlineNode {
2324    /// Consume this node and return its builder
2325    pub fn into_builder(self) -> CstBuilder {
2326        self.builder
2327    }
2328}
2329impl From<GrammarNewlineNode> for BuilderNodeId {
2330    fn from(node: GrammarNewlineNode) -> Self {
2331        node.node_id
2332    }
2333}
2334///Branded type for Hole non-terminal
2335#[derive(Debug, Clone)]
2336pub struct HoleNode {
2337    pub(super) node_id: BuilderNodeId,
2338    pub(super) builder: CstBuilder,
2339}
2340impl HoleNode {
2341    /// Consume this node and return its builder
2342    pub fn into_builder(self) -> CstBuilder {
2343        self.builder
2344    }
2345}
2346impl From<HoleNode> for BuilderNodeId {
2347    fn from(node: HoleNode) -> Self {
2348        node.node_id
2349    }
2350}
2351///Branded type for Ident non-terminal
2352#[derive(Debug, Clone)]
2353pub struct IdentNode {
2354    pub(super) node_id: BuilderNodeId,
2355    pub(super) builder: CstBuilder,
2356}
2357impl IdentNode {
2358    /// Consume this node and return its builder
2359    pub fn into_builder(self) -> CstBuilder {
2360        self.builder
2361    }
2362}
2363impl From<IdentNode> for BuilderNodeId {
2364    fn from(node: IdentNode) -> Self {
2365        node.node_id
2366    }
2367}
2368///Branded type for Inf non-terminal
2369#[derive(Debug, Clone)]
2370pub struct InfNode {
2371    pub(super) node_id: BuilderNodeId,
2372    pub(super) builder: CstBuilder,
2373}
2374impl InfNode {
2375    /// Consume this node and return its builder
2376    pub fn into_builder(self) -> CstBuilder {
2377        self.builder
2378    }
2379}
2380impl From<InfNode> for BuilderNodeId {
2381    fn from(node: InfNode) -> Self {
2382        node.node_id
2383    }
2384}
2385///Branded type for InlineCode non-terminal
2386#[derive(Debug, Clone)]
2387pub struct InlineCodeNode {
2388    pub(super) node_id: BuilderNodeId,
2389    pub(super) builder: CstBuilder,
2390}
2391impl InlineCodeNode {
2392    /// Consume this node and return its builder
2393    pub fn into_builder(self) -> CstBuilder {
2394        self.builder
2395    }
2396}
2397impl From<InlineCodeNode> for BuilderNodeId {
2398    fn from(node: InlineCodeNode) -> Self {
2399        node.node_id
2400    }
2401}
2402///Branded type for InlineCode1 non-terminal
2403#[derive(Debug, Clone)]
2404pub struct InlineCode1Node {
2405    pub(super) node_id: BuilderNodeId,
2406    pub(super) builder: CstBuilder,
2407}
2408impl InlineCode1Node {
2409    /// Consume this node and return its builder
2410    pub fn into_builder(self) -> CstBuilder {
2411        self.builder
2412    }
2413}
2414impl From<InlineCode1Node> for BuilderNodeId {
2415    fn from(node: InlineCode1Node) -> Self {
2416        node.node_id
2417    }
2418}
2419///Branded type for Integer non-terminal
2420#[derive(Debug, Clone)]
2421pub struct IntegerNode {
2422    pub(super) node_id: BuilderNodeId,
2423    pub(super) builder: CstBuilder,
2424}
2425impl IntegerNode {
2426    /// Consume this node and return its builder
2427    pub fn into_builder(self) -> CstBuilder {
2428        self.builder
2429    }
2430}
2431impl From<IntegerNode> for BuilderNodeId {
2432    fn from(node: IntegerNode) -> Self {
2433        node.node_id
2434    }
2435}
2436///Branded type for Key non-terminal
2437#[derive(Debug, Clone)]
2438pub struct KeyNode {
2439    pub(super) node_id: BuilderNodeId,
2440    pub(super) builder: CstBuilder,
2441}
2442impl KeyNode {
2443    /// Consume this node and return its builder
2444    pub fn into_builder(self) -> CstBuilder {
2445        self.builder
2446    }
2447}
2448impl From<KeyNode> for BuilderNodeId {
2449    fn from(node: KeyNode) -> Self {
2450        node.node_id
2451    }
2452}
2453///Branded type for KeyIdent non-terminal
2454#[derive(Debug, Clone)]
2455pub struct KeyIdentNode {
2456    pub(super) node_id: BuilderNodeId,
2457    pub(super) builder: CstBuilder,
2458}
2459impl KeyIdentNode {
2460    /// Consume this node and return its builder
2461    pub fn into_builder(self) -> CstBuilder {
2462        self.builder
2463    }
2464}
2465impl From<KeyIdentNode> for BuilderNodeId {
2466    fn from(node: KeyIdentNode) -> Self {
2467        node.node_id
2468    }
2469}
2470///Branded type for KeyTail non-terminal
2471#[derive(Debug, Clone)]
2472pub struct KeyTailNode {
2473    pub(super) node_id: BuilderNodeId,
2474    pub(super) builder: CstBuilder,
2475}
2476impl KeyTailNode {
2477    /// Consume this node and return its builder
2478    pub fn into_builder(self) -> CstBuilder {
2479        self.builder
2480    }
2481}
2482impl From<KeyTailNode> for BuilderNodeId {
2483    fn from(node: KeyTailNode) -> Self {
2484        node.node_id
2485    }
2486}
2487///Branded type for KeyTuple non-terminal
2488#[derive(Debug, Clone)]
2489pub struct KeyTupleNode {
2490    pub(super) node_id: BuilderNodeId,
2491    pub(super) builder: CstBuilder,
2492}
2493impl KeyTupleNode {
2494    /// Consume this node and return its builder
2495    pub fn into_builder(self) -> CstBuilder {
2496        self.builder
2497    }
2498}
2499impl From<KeyTupleNode> for BuilderNodeId {
2500    fn from(node: KeyTupleNode) -> Self {
2501        node.node_id
2502    }
2503}
2504///Branded type for KeyTupleElements non-terminal
2505#[derive(Debug, Clone)]
2506pub struct KeyTupleElementsNode {
2507    pub(super) node_id: BuilderNodeId,
2508    pub(super) builder: CstBuilder,
2509}
2510impl KeyTupleElementsNode {
2511    /// Consume this node and return its builder
2512    pub fn into_builder(self) -> CstBuilder {
2513        self.builder
2514    }
2515}
2516impl From<KeyTupleElementsNode> for BuilderNodeId {
2517    fn from(node: KeyTupleElementsNode) -> Self {
2518        node.node_id
2519    }
2520}
2521///Branded type for KeyTupleElementsOpt non-terminal
2522#[derive(Debug, Clone)]
2523pub struct KeyTupleElementsOptNode {
2524    pub(super) node_id: BuilderNodeId,
2525    pub(super) builder: CstBuilder,
2526}
2527impl KeyTupleElementsOptNode {
2528    /// Consume this node and return its builder
2529    pub fn into_builder(self) -> CstBuilder {
2530        self.builder
2531    }
2532}
2533impl From<KeyTupleElementsOptNode> for BuilderNodeId {
2534    fn from(node: KeyTupleElementsOptNode) -> Self {
2535        node.node_id
2536    }
2537}
2538///Branded type for KeyTupleElementsTail non-terminal
2539#[derive(Debug, Clone)]
2540pub struct KeyTupleElementsTailNode {
2541    pub(super) node_id: BuilderNodeId,
2542    pub(super) builder: CstBuilder,
2543}
2544impl KeyTupleElementsTailNode {
2545    /// Consume this node and return its builder
2546    pub fn into_builder(self) -> CstBuilder {
2547        self.builder
2548    }
2549}
2550impl From<KeyTupleElementsTailNode> for BuilderNodeId {
2551    fn from(node: KeyTupleElementsTailNode) -> Self {
2552        node.node_id
2553    }
2554}
2555///Branded type for KeyTupleElementsTailOpt non-terminal
2556#[derive(Debug, Clone)]
2557pub struct KeyTupleElementsTailOptNode {
2558    pub(super) node_id: BuilderNodeId,
2559    pub(super) builder: CstBuilder,
2560}
2561impl KeyTupleElementsTailOptNode {
2562    /// Consume this node and return its builder
2563    pub fn into_builder(self) -> CstBuilder {
2564        self.builder
2565    }
2566}
2567impl From<KeyTupleElementsTailOptNode> for BuilderNodeId {
2568    fn from(node: KeyTupleElementsTailOptNode) -> Self {
2569        node.node_id
2570    }
2571}
2572///Branded type for KeyTupleOpt non-terminal
2573#[derive(Debug, Clone)]
2574pub struct KeyTupleOptNode {
2575    pub(super) node_id: BuilderNodeId,
2576    pub(super) builder: CstBuilder,
2577}
2578impl KeyTupleOptNode {
2579    /// Consume this node and return its builder
2580    pub fn into_builder(self) -> CstBuilder {
2581        self.builder
2582    }
2583}
2584impl From<KeyTupleOptNode> for BuilderNodeId {
2585    fn from(node: KeyTupleOptNode) -> Self {
2586        node.node_id
2587    }
2588}
2589///Branded type for KeyValue non-terminal
2590#[derive(Debug, Clone)]
2591pub struct KeyValueNode {
2592    pub(super) node_id: BuilderNodeId,
2593    pub(super) builder: CstBuilder,
2594}
2595impl KeyValueNode {
2596    /// Consume this node and return its builder
2597    pub fn into_builder(self) -> CstBuilder {
2598        self.builder
2599    }
2600}
2601impl From<KeyValueNode> for BuilderNodeId {
2602    fn from(node: KeyValueNode) -> Self {
2603        node.node_id
2604    }
2605}
2606///Branded type for Keys non-terminal
2607#[derive(Debug, Clone)]
2608pub struct KeysNode {
2609    pub(super) node_id: BuilderNodeId,
2610    pub(super) builder: CstBuilder,
2611}
2612impl KeysNode {
2613    /// Consume this node and return its builder
2614    pub fn into_builder(self) -> CstBuilder {
2615        self.builder
2616    }
2617}
2618impl From<KeysNode> for BuilderNodeId {
2619    fn from(node: KeysNode) -> Self {
2620        node.node_id
2621    }
2622}
2623///Branded type for KeysList non-terminal
2624#[derive(Debug, Clone)]
2625pub struct KeysListNode {
2626    pub(super) node_id: BuilderNodeId,
2627    pub(super) builder: CstBuilder,
2628}
2629impl KeysListNode {
2630    /// Consume this node and return its builder
2631    pub fn into_builder(self) -> CstBuilder {
2632        self.builder
2633    }
2634}
2635impl From<KeysListNode> for BuilderNodeId {
2636    fn from(node: KeysListNode) -> Self {
2637        node.node_id
2638    }
2639}
2640///Branded type for LParen non-terminal
2641#[derive(Debug, Clone)]
2642pub struct LParenNode {
2643    pub(super) node_id: BuilderNodeId,
2644    pub(super) builder: CstBuilder,
2645}
2646impl LParenNode {
2647    /// Consume this node and return its builder
2648    pub fn into_builder(self) -> CstBuilder {
2649        self.builder
2650    }
2651}
2652impl From<LParenNode> for BuilderNodeId {
2653    fn from(node: LParenNode) -> Self {
2654        node.node_id
2655    }
2656}
2657///Branded type for LitStr non-terminal
2658#[derive(Debug, Clone)]
2659pub struct LitStrNode {
2660    pub(super) node_id: BuilderNodeId,
2661    pub(super) builder: CstBuilder,
2662}
2663impl LitStrNode {
2664    /// Consume this node and return its builder
2665    pub fn into_builder(self) -> CstBuilder {
2666        self.builder
2667    }
2668}
2669impl From<LitStrNode> for BuilderNodeId {
2670    fn from(node: LitStrNode) -> Self {
2671        node.node_id
2672    }
2673}
2674///Branded type for LitStr1 non-terminal
2675#[derive(Debug, Clone)]
2676pub struct LitStr1Node {
2677    pub(super) node_id: BuilderNodeId,
2678    pub(super) builder: CstBuilder,
2679}
2680impl LitStr1Node {
2681    /// Consume this node and return its builder
2682    pub fn into_builder(self) -> CstBuilder {
2683        self.builder
2684    }
2685}
2686impl From<LitStr1Node> for BuilderNodeId {
2687    fn from(node: LitStr1Node) -> Self {
2688        node.node_id
2689    }
2690}
2691///Branded type for LitStr1End non-terminal
2692#[derive(Debug, Clone)]
2693pub struct LitStr1EndNode {
2694    pub(super) node_id: BuilderNodeId,
2695    pub(super) builder: CstBuilder,
2696}
2697impl LitStr1EndNode {
2698    /// Consume this node and return its builder
2699    pub fn into_builder(self) -> CstBuilder {
2700        self.builder
2701    }
2702}
2703impl From<LitStr1EndNode> for BuilderNodeId {
2704    fn from(node: LitStr1EndNode) -> Self {
2705        node.node_id
2706    }
2707}
2708///Branded type for LitStr1List non-terminal
2709#[derive(Debug, Clone)]
2710pub struct LitStr1ListNode {
2711    pub(super) node_id: BuilderNodeId,
2712    pub(super) builder: CstBuilder,
2713}
2714impl LitStr1ListNode {
2715    /// Consume this node and return its builder
2716    pub fn into_builder(self) -> CstBuilder {
2717        self.builder
2718    }
2719}
2720impl From<LitStr1ListNode> for BuilderNodeId {
2721    fn from(node: LitStr1ListNode) -> Self {
2722        node.node_id
2723    }
2724}
2725///Branded type for LitStr1ListGroup non-terminal
2726#[derive(Debug, Clone)]
2727pub struct LitStr1ListGroupNode {
2728    pub(super) node_id: BuilderNodeId,
2729    pub(super) builder: CstBuilder,
2730}
2731impl LitStr1ListGroupNode {
2732    /// Consume this node and return its builder
2733    pub fn into_builder(self) -> CstBuilder {
2734        self.builder
2735    }
2736}
2737impl From<LitStr1ListGroupNode> for BuilderNodeId {
2738    fn from(node: LitStr1ListGroupNode) -> Self {
2739        node.node_id
2740    }
2741}
2742///Branded type for LitStr1Start non-terminal
2743#[derive(Debug, Clone)]
2744pub struct LitStr1StartNode {
2745    pub(super) node_id: BuilderNodeId,
2746    pub(super) builder: CstBuilder,
2747}
2748impl LitStr1StartNode {
2749    /// Consume this node and return its builder
2750    pub fn into_builder(self) -> CstBuilder {
2751        self.builder
2752    }
2753}
2754impl From<LitStr1StartNode> for BuilderNodeId {
2755    fn from(node: LitStr1StartNode) -> Self {
2756        node.node_id
2757    }
2758}
2759///Branded type for LitStr2 non-terminal
2760#[derive(Debug, Clone)]
2761pub struct LitStr2Node {
2762    pub(super) node_id: BuilderNodeId,
2763    pub(super) builder: CstBuilder,
2764}
2765impl LitStr2Node {
2766    /// Consume this node and return its builder
2767    pub fn into_builder(self) -> CstBuilder {
2768        self.builder
2769    }
2770}
2771impl From<LitStr2Node> for BuilderNodeId {
2772    fn from(node: LitStr2Node) -> Self {
2773        node.node_id
2774    }
2775}
2776///Branded type for LitStr2End non-terminal
2777#[derive(Debug, Clone)]
2778pub struct LitStr2EndNode {
2779    pub(super) node_id: BuilderNodeId,
2780    pub(super) builder: CstBuilder,
2781}
2782impl LitStr2EndNode {
2783    /// Consume this node and return its builder
2784    pub fn into_builder(self) -> CstBuilder {
2785        self.builder
2786    }
2787}
2788impl From<LitStr2EndNode> for BuilderNodeId {
2789    fn from(node: LitStr2EndNode) -> Self {
2790        node.node_id
2791    }
2792}
2793///Branded type for LitStr2List non-terminal
2794#[derive(Debug, Clone)]
2795pub struct LitStr2ListNode {
2796    pub(super) node_id: BuilderNodeId,
2797    pub(super) builder: CstBuilder,
2798}
2799impl LitStr2ListNode {
2800    /// Consume this node and return its builder
2801    pub fn into_builder(self) -> CstBuilder {
2802        self.builder
2803    }
2804}
2805impl From<LitStr2ListNode> for BuilderNodeId {
2806    fn from(node: LitStr2ListNode) -> Self {
2807        node.node_id
2808    }
2809}
2810///Branded type for LitStr2ListGroup non-terminal
2811#[derive(Debug, Clone)]
2812pub struct LitStr2ListGroupNode {
2813    pub(super) node_id: BuilderNodeId,
2814    pub(super) builder: CstBuilder,
2815}
2816impl LitStr2ListGroupNode {
2817    /// Consume this node and return its builder
2818    pub fn into_builder(self) -> CstBuilder {
2819        self.builder
2820    }
2821}
2822impl From<LitStr2ListGroupNode> for BuilderNodeId {
2823    fn from(node: LitStr2ListGroupNode) -> Self {
2824        node.node_id
2825    }
2826}
2827///Branded type for LitStr2Start non-terminal
2828#[derive(Debug, Clone)]
2829pub struct LitStr2StartNode {
2830    pub(super) node_id: BuilderNodeId,
2831    pub(super) builder: CstBuilder,
2832}
2833impl LitStr2StartNode {
2834    /// Consume this node and return its builder
2835    pub fn into_builder(self) -> CstBuilder {
2836        self.builder
2837    }
2838}
2839impl From<LitStr2StartNode> for BuilderNodeId {
2840    fn from(node: LitStr2StartNode) -> Self {
2841        node.node_id
2842    }
2843}
2844///Branded type for LitStr3 non-terminal
2845#[derive(Debug, Clone)]
2846pub struct LitStr3Node {
2847    pub(super) node_id: BuilderNodeId,
2848    pub(super) builder: CstBuilder,
2849}
2850impl LitStr3Node {
2851    /// Consume this node and return its builder
2852    pub fn into_builder(self) -> CstBuilder {
2853        self.builder
2854    }
2855}
2856impl From<LitStr3Node> for BuilderNodeId {
2857    fn from(node: LitStr3Node) -> Self {
2858        node.node_id
2859    }
2860}
2861///Branded type for LitStr3End non-terminal
2862#[derive(Debug, Clone)]
2863pub struct LitStr3EndNode {
2864    pub(super) node_id: BuilderNodeId,
2865    pub(super) builder: CstBuilder,
2866}
2867impl LitStr3EndNode {
2868    /// Consume this node and return its builder
2869    pub fn into_builder(self) -> CstBuilder {
2870        self.builder
2871    }
2872}
2873impl From<LitStr3EndNode> for BuilderNodeId {
2874    fn from(node: LitStr3EndNode) -> Self {
2875        node.node_id
2876    }
2877}
2878///Branded type for LitStr3List non-terminal
2879#[derive(Debug, Clone)]
2880pub struct LitStr3ListNode {
2881    pub(super) node_id: BuilderNodeId,
2882    pub(super) builder: CstBuilder,
2883}
2884impl LitStr3ListNode {
2885    /// Consume this node and return its builder
2886    pub fn into_builder(self) -> CstBuilder {
2887        self.builder
2888    }
2889}
2890impl From<LitStr3ListNode> for BuilderNodeId {
2891    fn from(node: LitStr3ListNode) -> Self {
2892        node.node_id
2893    }
2894}
2895///Branded type for LitStr3ListGroup non-terminal
2896#[derive(Debug, Clone)]
2897pub struct LitStr3ListGroupNode {
2898    pub(super) node_id: BuilderNodeId,
2899    pub(super) builder: CstBuilder,
2900}
2901impl LitStr3ListGroupNode {
2902    /// Consume this node and return its builder
2903    pub fn into_builder(self) -> CstBuilder {
2904        self.builder
2905    }
2906}
2907impl From<LitStr3ListGroupNode> for BuilderNodeId {
2908    fn from(node: LitStr3ListGroupNode) -> Self {
2909        node.node_id
2910    }
2911}
2912///Branded type for LitStr3Start non-terminal
2913#[derive(Debug, Clone)]
2914pub struct LitStr3StartNode {
2915    pub(super) node_id: BuilderNodeId,
2916    pub(super) builder: CstBuilder,
2917}
2918impl LitStr3StartNode {
2919    /// Consume this node and return its builder
2920    pub fn into_builder(self) -> CstBuilder {
2921        self.builder
2922    }
2923}
2924impl From<LitStr3StartNode> for BuilderNodeId {
2925    fn from(node: LitStr3StartNode) -> Self {
2926        node.node_id
2927    }
2928}
2929///Branded type for MapBind non-terminal
2930#[derive(Debug, Clone)]
2931pub struct MapBindNode {
2932    pub(super) node_id: BuilderNodeId,
2933    pub(super) builder: CstBuilder,
2934}
2935impl MapBindNode {
2936    /// Consume this node and return its builder
2937    pub fn into_builder(self) -> CstBuilder {
2938        self.builder
2939    }
2940}
2941impl From<MapBindNode> for BuilderNodeId {
2942    fn from(node: MapBindNode) -> Self {
2943        node.node_id
2944    }
2945}
2946///Branded type for NaN non-terminal
2947#[derive(Debug, Clone)]
2948pub struct NaNNode {
2949    pub(super) node_id: BuilderNodeId,
2950    pub(super) builder: CstBuilder,
2951}
2952impl NaNNode {
2953    /// Consume this node and return its builder
2954    pub fn into_builder(self) -> CstBuilder {
2955        self.builder
2956    }
2957}
2958impl From<NaNNode> for BuilderNodeId {
2959    fn from(node: NaNNode) -> Self {
2960        node.node_id
2961    }
2962}
2963///Branded type for NewlineBind non-terminal
2964#[derive(Debug, Clone)]
2965pub struct NewlineBindNode {
2966    pub(super) node_id: BuilderNodeId,
2967    pub(super) builder: CstBuilder,
2968}
2969impl NewlineBindNode {
2970    /// Consume this node and return its builder
2971    pub fn into_builder(self) -> CstBuilder {
2972        self.builder
2973    }
2974}
2975impl From<NewlineBindNode> for BuilderNodeId {
2976    fn from(node: NewlineBindNode) -> Self {
2977        node.node_id
2978    }
2979}
2980///Branded type for NewlineHead non-terminal
2981#[derive(Debug, Clone)]
2982pub struct NewlineHeadNode {
2983    pub(super) node_id: BuilderNodeId,
2984    pub(super) builder: CstBuilder,
2985}
2986impl NewlineHeadNode {
2987    /// Consume this node and return its builder
2988    pub fn into_builder(self) -> CstBuilder {
2989        self.builder
2990    }
2991}
2992impl From<NewlineHeadNode> for BuilderNodeId {
2993    fn from(node: NewlineHeadNode) -> Self {
2994        node.node_id
2995    }
2996}
2997///Branded type for NewlineHeadOpt non-terminal
2998#[derive(Debug, Clone)]
2999pub struct NewlineHeadOptNode {
3000    pub(super) node_id: BuilderNodeId,
3001    pub(super) builder: CstBuilder,
3002}
3003impl NewlineHeadOptNode {
3004    /// Consume this node and return its builder
3005    pub fn into_builder(self) -> CstBuilder {
3006        self.builder
3007    }
3008}
3009impl From<NewlineHeadOptNode> for BuilderNodeId {
3010    fn from(node: NewlineHeadOptNode) -> Self {
3011        node.node_id
3012    }
3013}
3014///Branded type for NewlineTextStart non-terminal
3015#[derive(Debug, Clone)]
3016pub struct NewlineTextStartNode {
3017    pub(super) node_id: BuilderNodeId,
3018    pub(super) builder: CstBuilder,
3019}
3020impl NewlineTextStartNode {
3021    /// Consume this node and return its builder
3022    pub fn into_builder(self) -> CstBuilder {
3023        self.builder
3024    }
3025}
3026impl From<NewlineTextStartNode> for BuilderNodeId {
3027    fn from(node: NewlineTextStartNode) -> Self {
3028        node.node_id
3029    }
3030}
3031///Branded type for NoBacktick non-terminal
3032#[derive(Debug, Clone)]
3033pub struct NoBacktickNode {
3034    pub(super) node_id: BuilderNodeId,
3035    pub(super) builder: CstBuilder,
3036}
3037impl NoBacktickNode {
3038    /// Consume this node and return its builder
3039    pub fn into_builder(self) -> CstBuilder {
3040        self.builder
3041    }
3042}
3043impl From<NoBacktickNode> for BuilderNodeId {
3044    fn from(node: NoBacktickNode) -> Self {
3045        node.node_id
3046    }
3047}
3048///Branded type for NoSQuote non-terminal
3049#[derive(Debug, Clone)]
3050pub struct NoSQuoteNode {
3051    pub(super) node_id: BuilderNodeId,
3052    pub(super) builder: CstBuilder,
3053}
3054impl NoSQuoteNode {
3055    /// Consume this node and return its builder
3056    pub fn into_builder(self) -> CstBuilder {
3057        self.builder
3058    }
3059}
3060impl From<NoSQuoteNode> for BuilderNodeId {
3061    fn from(node: NoSQuoteNode) -> Self {
3062        node.node_id
3063    }
3064}
3065///Branded type for Null non-terminal
3066#[derive(Debug, Clone)]
3067pub struct NullNode {
3068    pub(super) node_id: BuilderNodeId,
3069    pub(super) builder: CstBuilder,
3070}
3071impl NullNode {
3072    /// Consume this node and return its builder
3073    pub fn into_builder(self) -> CstBuilder {
3074        self.builder
3075    }
3076}
3077impl From<NullNode> for BuilderNodeId {
3078    fn from(node: NullNode) -> Self {
3079        node.node_id
3080    }
3081}
3082///Branded type for Number non-terminal
3083#[derive(Debug, Clone)]
3084pub struct NumberNode {
3085    pub(super) node_id: BuilderNodeId,
3086    pub(super) builder: CstBuilder,
3087}
3088impl NumberNode {
3089    /// Consume this node and return its builder
3090    pub fn into_builder(self) -> CstBuilder {
3091        self.builder
3092    }
3093}
3094impl From<NumberNode> for BuilderNodeId {
3095    fn from(node: NumberNode) -> Self {
3096        node.node_id
3097    }
3098}
3099///Branded type for Object non-terminal
3100#[derive(Debug, Clone)]
3101pub struct ObjectNode {
3102    pub(super) node_id: BuilderNodeId,
3103    pub(super) builder: CstBuilder,
3104}
3105impl ObjectNode {
3106    /// Consume this node and return its builder
3107    pub fn into_builder(self) -> CstBuilder {
3108        self.builder
3109    }
3110}
3111impl From<ObjectNode> for BuilderNodeId {
3112    fn from(node: ObjectNode) -> Self {
3113        node.node_id
3114    }
3115}
3116///Branded type for ObjectList non-terminal
3117#[derive(Debug, Clone)]
3118pub struct ObjectListNode {
3119    pub(super) node_id: BuilderNodeId,
3120    pub(super) builder: CstBuilder,
3121}
3122impl ObjectListNode {
3123    /// Consume this node and return its builder
3124    pub fn into_builder(self) -> CstBuilder {
3125        self.builder
3126    }
3127}
3128impl From<ObjectListNode> for BuilderNodeId {
3129    fn from(node: ObjectListNode) -> Self {
3130        node.node_id
3131    }
3132}
3133///Branded type for ObjectOpt non-terminal
3134#[derive(Debug, Clone)]
3135pub struct ObjectOptNode {
3136    pub(super) node_id: BuilderNodeId,
3137    pub(super) builder: CstBuilder,
3138}
3139impl ObjectOptNode {
3140    /// Consume this node and return its builder
3141    pub fn into_builder(self) -> CstBuilder {
3142        self.builder
3143    }
3144}
3145impl From<ObjectOptNode> for BuilderNodeId {
3146    fn from(node: ObjectOptNode) -> Self {
3147        node.node_id
3148    }
3149}
3150///Branded type for ObjectOpt0 non-terminal
3151#[derive(Debug, Clone)]
3152pub struct ObjectOpt0Node {
3153    pub(super) node_id: BuilderNodeId,
3154    pub(super) builder: CstBuilder,
3155}
3156impl ObjectOpt0Node {
3157    /// Consume this node and return its builder
3158    pub fn into_builder(self) -> CstBuilder {
3159        self.builder
3160    }
3161}
3162impl From<ObjectOpt0Node> for BuilderNodeId {
3163    fn from(node: ObjectOpt0Node) -> Self {
3164        node.node_id
3165    }
3166}
3167///Branded type for ObjectOpt1 non-terminal
3168#[derive(Debug, Clone)]
3169pub struct ObjectOpt1Node {
3170    pub(super) node_id: BuilderNodeId,
3171    pub(super) builder: CstBuilder,
3172}
3173impl ObjectOpt1Node {
3174    /// Consume this node and return its builder
3175    pub fn into_builder(self) -> CstBuilder {
3176        self.builder
3177    }
3178}
3179impl From<ObjectOpt1Node> for BuilderNodeId {
3180    fn from(node: ObjectOpt1Node) -> Self {
3181        node.node_id
3182    }
3183}
3184///Branded type for RParen non-terminal
3185#[derive(Debug, Clone)]
3186pub struct RParenNode {
3187    pub(super) node_id: BuilderNodeId,
3188    pub(super) builder: CstBuilder,
3189}
3190impl RParenNode {
3191    /// Consume this node and return its builder
3192    pub fn into_builder(self) -> CstBuilder {
3193        self.builder
3194    }
3195}
3196impl From<RParenNode> for BuilderNodeId {
3197    fn from(node: RParenNode) -> Self {
3198        node.node_id
3199    }
3200}
3201///Branded type for RootBinding non-terminal
3202#[derive(Debug, Clone)]
3203pub struct RootBindingNode {
3204    pub(super) node_id: BuilderNodeId,
3205    pub(super) builder: CstBuilder,
3206}
3207impl RootBindingNode {
3208    /// Consume this node and return its builder
3209    pub fn into_builder(self) -> CstBuilder {
3210        self.builder
3211    }
3212}
3213impl From<RootBindingNode> for BuilderNodeId {
3214    fn from(node: RootBindingNode) -> Self {
3215        node.node_id
3216    }
3217}
3218///Branded type for RootTextBinding non-terminal
3219#[derive(Debug, Clone)]
3220pub struct RootTextBindingNode {
3221    pub(super) node_id: BuilderNodeId,
3222    pub(super) builder: CstBuilder,
3223}
3224impl RootTextBindingNode {
3225    /// Consume this node and return its builder
3226    pub fn into_builder(self) -> CstBuilder {
3227        self.builder
3228    }
3229}
3230impl From<RootTextBindingNode> for BuilderNodeId {
3231    fn from(node: RootTextBindingNode) -> Self {
3232        node.node_id
3233    }
3234}
3235///Branded type for RootTextBindingOpt non-terminal
3236#[derive(Debug, Clone)]
3237pub struct RootTextBindingOptNode {
3238    pub(super) node_id: BuilderNodeId,
3239    pub(super) builder: CstBuilder,
3240}
3241impl RootTextBindingOptNode {
3242    /// Consume this node and return its builder
3243    pub fn into_builder(self) -> CstBuilder {
3244        self.builder
3245    }
3246}
3247impl From<RootTextBindingOptNode> for BuilderNodeId {
3248    fn from(node: RootTextBindingOptNode) -> Self {
3249        node.node_id
3250    }
3251}
3252///Branded type for RootTextBindingOpt0 non-terminal
3253#[derive(Debug, Clone)]
3254pub struct RootTextBindingOpt0Node {
3255    pub(super) node_id: BuilderNodeId,
3256    pub(super) builder: CstBuilder,
3257}
3258impl RootTextBindingOpt0Node {
3259    /// Consume this node and return its builder
3260    pub fn into_builder(self) -> CstBuilder {
3261        self.builder
3262    }
3263}
3264impl From<RootTextBindingOpt0Node> for BuilderNodeId {
3265    fn from(node: RootTextBindingOpt0Node) -> Self {
3266        node.node_id
3267    }
3268}
3269///Branded type for RootTextBindingOpt1 non-terminal
3270#[derive(Debug, Clone)]
3271pub struct RootTextBindingOpt1Node {
3272    pub(super) node_id: BuilderNodeId,
3273    pub(super) builder: CstBuilder,
3274}
3275impl RootTextBindingOpt1Node {
3276    /// Consume this node and return its builder
3277    pub fn into_builder(self) -> CstBuilder {
3278        self.builder
3279    }
3280}
3281impl From<RootTextBindingOpt1Node> for BuilderNodeId {
3282    fn from(node: RootTextBindingOpt1Node) -> Self {
3283        node.node_id
3284    }
3285}
3286///Branded type for RootValueBinding non-terminal
3287#[derive(Debug, Clone)]
3288pub struct RootValueBindingNode {
3289    pub(super) node_id: BuilderNodeId,
3290    pub(super) builder: CstBuilder,
3291}
3292impl RootValueBindingNode {
3293    /// Consume this node and return its builder
3294    pub fn into_builder(self) -> CstBuilder {
3295        self.builder
3296    }
3297}
3298impl From<RootValueBindingNode> for BuilderNodeId {
3299    fn from(node: RootValueBindingNode) -> Self {
3300        node.node_id
3301    }
3302}
3303///Branded type for SQuote non-terminal
3304#[derive(Debug, Clone)]
3305pub struct SQuoteNode {
3306    pub(super) node_id: BuilderNodeId,
3307    pub(super) builder: CstBuilder,
3308}
3309impl SQuoteNode {
3310    /// Consume this node and return its builder
3311    pub fn into_builder(self) -> CstBuilder {
3312        self.builder
3313    }
3314}
3315impl From<SQuoteNode> for BuilderNodeId {
3316    fn from(node: SQuoteNode) -> Self {
3317        node.node_id
3318    }
3319}
3320///Branded type for Section non-terminal
3321#[derive(Debug, Clone)]
3322pub struct SectionNode {
3323    pub(super) node_id: BuilderNodeId,
3324    pub(super) builder: CstBuilder,
3325}
3326impl SectionNode {
3327    /// Consume this node and return its builder
3328    pub fn into_builder(self) -> CstBuilder {
3329        self.builder
3330    }
3331}
3332impl From<SectionNode> for BuilderNodeId {
3333    fn from(node: SectionNode) -> Self {
3334        node.node_id
3335    }
3336}
3337///Branded type for SectionBinding non-terminal
3338#[derive(Debug, Clone)]
3339pub struct SectionBindingNode {
3340    pub(super) node_id: BuilderNodeId,
3341    pub(super) builder: CstBuilder,
3342}
3343impl SectionBindingNode {
3344    /// Consume this node and return its builder
3345    pub fn into_builder(self) -> CstBuilder {
3346        self.builder
3347    }
3348}
3349impl From<SectionBindingNode> for BuilderNodeId {
3350    fn from(node: SectionBindingNode) -> Self {
3351        node.node_id
3352    }
3353}
3354///Branded type for SectionBody non-terminal
3355#[derive(Debug, Clone)]
3356pub struct SectionBodyNode {
3357    pub(super) node_id: BuilderNodeId,
3358    pub(super) builder: CstBuilder,
3359}
3360impl SectionBodyNode {
3361    /// Consume this node and return its builder
3362    pub fn into_builder(self) -> CstBuilder {
3363        self.builder
3364    }
3365}
3366impl From<SectionBodyNode> for BuilderNodeId {
3367    fn from(node: SectionBodyNode) -> Self {
3368        node.node_id
3369    }
3370}
3371///Branded type for SectionBodyOpt non-terminal
3372#[derive(Debug, Clone)]
3373pub struct SectionBodyOptNode {
3374    pub(super) node_id: BuilderNodeId,
3375    pub(super) builder: CstBuilder,
3376}
3377impl SectionBodyOptNode {
3378    /// Consume this node and return its builder
3379    pub fn into_builder(self) -> CstBuilder {
3380        self.builder
3381    }
3382}
3383impl From<SectionBodyOptNode> for BuilderNodeId {
3384    fn from(node: SectionBodyOptNode) -> Self {
3385        node.node_id
3386    }
3387}
3388///Branded type for SectionHead non-terminal
3389#[derive(Debug, Clone)]
3390pub struct SectionHeadNode {
3391    pub(super) node_id: BuilderNodeId,
3392    pub(super) builder: CstBuilder,
3393}
3394impl SectionHeadNode {
3395    /// Consume this node and return its builder
3396    pub fn into_builder(self) -> CstBuilder {
3397        self.builder
3398    }
3399}
3400impl From<SectionHeadNode> for BuilderNodeId {
3401    fn from(node: SectionHeadNode) -> Self {
3402        node.node_id
3403    }
3404}
3405///Branded type for Str non-terminal
3406#[derive(Debug, Clone)]
3407pub struct StrNode {
3408    pub(super) node_id: BuilderNodeId,
3409    pub(super) builder: CstBuilder,
3410}
3411impl StrNode {
3412    /// Consume this node and return its builder
3413    pub fn into_builder(self) -> CstBuilder {
3414        self.builder
3415    }
3416}
3417impl From<StrNode> for BuilderNodeId {
3418    fn from(node: StrNode) -> Self {
3419        node.node_id
3420    }
3421}
3422///Branded type for String non-terminal
3423#[derive(Debug, Clone)]
3424pub struct StringNode {
3425    pub(super) node_id: BuilderNodeId,
3426    pub(super) builder: CstBuilder,
3427}
3428impl StringNode {
3429    /// Consume this node and return its builder
3430    pub fn into_builder(self) -> CstBuilder {
3431        self.builder
3432    }
3433}
3434impl From<StringNode> for BuilderNodeId {
3435    fn from(node: StringNode) -> Self {
3436        node.node_id
3437    }
3438}
3439///Branded type for Strings non-terminal
3440#[derive(Debug, Clone)]
3441pub struct StringsNode {
3442    pub(super) node_id: BuilderNodeId,
3443    pub(super) builder: CstBuilder,
3444}
3445impl StringsNode {
3446    /// Consume this node and return its builder
3447    pub fn into_builder(self) -> CstBuilder {
3448        self.builder
3449    }
3450}
3451impl From<StringsNode> for BuilderNodeId {
3452    fn from(node: StringsNode) -> Self {
3453        node.node_id
3454    }
3455}
3456///Branded type for StringsList non-terminal
3457#[derive(Debug, Clone)]
3458pub struct StringsListNode {
3459    pub(super) node_id: BuilderNodeId,
3460    pub(super) builder: CstBuilder,
3461}
3462impl StringsListNode {
3463    /// Consume this node and return its builder
3464    pub fn into_builder(self) -> CstBuilder {
3465        self.builder
3466    }
3467}
3468impl From<StringsListNode> for BuilderNodeId {
3469    fn from(node: StringsListNode) -> Self {
3470        node.node_id
3471    }
3472}
3473///Branded type for Text non-terminal
3474#[derive(Debug, Clone)]
3475pub struct TextNode {
3476    pub(super) node_id: BuilderNodeId,
3477    pub(super) builder: CstBuilder,
3478}
3479impl TextNode {
3480    /// Consume this node and return its builder
3481    pub fn into_builder(self) -> CstBuilder {
3482        self.builder
3483    }
3484}
3485impl From<TextNode> for BuilderNodeId {
3486    fn from(node: TextNode) -> Self {
3487        node.node_id
3488    }
3489}
3490///Branded type for TextBinding non-terminal
3491#[derive(Debug, Clone)]
3492pub struct TextBindingNode {
3493    pub(super) node_id: BuilderNodeId,
3494    pub(super) builder: CstBuilder,
3495}
3496impl TextBindingNode {
3497    /// Consume this node and return its builder
3498    pub fn into_builder(self) -> CstBuilder {
3499        self.builder
3500    }
3501}
3502impl From<TextBindingNode> for BuilderNodeId {
3503    fn from(node: TextBindingNode) -> Self {
3504        node.node_id
3505    }
3506}
3507///Branded type for TextBindingOpt non-terminal
3508#[derive(Debug, Clone)]
3509pub struct TextBindingOptNode {
3510    pub(super) node_id: BuilderNodeId,
3511    pub(super) builder: CstBuilder,
3512}
3513impl TextBindingOptNode {
3514    /// Consume this node and return its builder
3515    pub fn into_builder(self) -> CstBuilder {
3516        self.builder
3517    }
3518}
3519impl From<TextBindingOptNode> for BuilderNodeId {
3520    fn from(node: TextBindingOptNode) -> Self {
3521        node.node_id
3522    }
3523}
3524///Branded type for TextBindingOpt0 non-terminal
3525#[derive(Debug, Clone)]
3526pub struct TextBindingOpt0Node {
3527    pub(super) node_id: BuilderNodeId,
3528    pub(super) builder: CstBuilder,
3529}
3530impl TextBindingOpt0Node {
3531    /// Consume this node and return its builder
3532    pub fn into_builder(self) -> CstBuilder {
3533        self.builder
3534    }
3535}
3536impl From<TextBindingOpt0Node> for BuilderNodeId {
3537    fn from(node: TextBindingOpt0Node) -> Self {
3538        node.node_id
3539    }
3540}
3541///Branded type for TextBindingOpt1 non-terminal
3542#[derive(Debug, Clone)]
3543pub struct TextBindingOpt1Node {
3544    pub(super) node_id: BuilderNodeId,
3545    pub(super) builder: CstBuilder,
3546}
3547impl TextBindingOpt1Node {
3548    /// Consume this node and return its builder
3549    pub fn into_builder(self) -> CstBuilder {
3550        self.builder
3551    }
3552}
3553impl From<TextBindingOpt1Node> for BuilderNodeId {
3554    fn from(node: TextBindingOpt1Node) -> Self {
3555        node.node_id
3556    }
3557}
3558///Branded type for TextStart non-terminal
3559#[derive(Debug, Clone)]
3560pub struct TextStartNode {
3561    pub(super) node_id: BuilderNodeId,
3562    pub(super) builder: CstBuilder,
3563}
3564impl TextStartNode {
3565    /// Consume this node and return its builder
3566    pub fn into_builder(self) -> CstBuilder {
3567        self.builder
3568    }
3569}
3570impl From<TextStartNode> for BuilderNodeId {
3571    fn from(node: TextStartNode) -> Self {
3572        node.node_id
3573    }
3574}
3575///Branded type for TopLevelBinding non-terminal
3576#[derive(Debug, Clone)]
3577pub struct TopLevelBindingNode {
3578    pub(super) node_id: BuilderNodeId,
3579    pub(super) builder: CstBuilder,
3580}
3581impl TopLevelBindingNode {
3582    /// Consume this node and return its builder
3583    pub fn into_builder(self) -> CstBuilder {
3584        self.builder
3585    }
3586}
3587impl From<TopLevelBindingNode> for BuilderNodeId {
3588    fn from(node: TopLevelBindingNode) -> Self {
3589        node.node_id
3590    }
3591}
3592///Branded type for True non-terminal
3593#[derive(Debug, Clone)]
3594pub struct TrueNode {
3595    pub(super) node_id: BuilderNodeId,
3596    pub(super) builder: CstBuilder,
3597}
3598impl TrueNode {
3599    /// Consume this node and return its builder
3600    pub fn into_builder(self) -> CstBuilder {
3601        self.builder
3602    }
3603}
3604impl From<TrueNode> for BuilderNodeId {
3605    fn from(node: TrueNode) -> Self {
3606        node.node_id
3607    }
3608}
3609///Branded type for Tuple non-terminal
3610#[derive(Debug, Clone)]
3611pub struct TupleNode {
3612    pub(super) node_id: BuilderNodeId,
3613    pub(super) builder: CstBuilder,
3614}
3615impl TupleNode {
3616    /// Consume this node and return its builder
3617    pub fn into_builder(self) -> CstBuilder {
3618        self.builder
3619    }
3620}
3621impl From<TupleNode> for BuilderNodeId {
3622    fn from(node: TupleNode) -> Self {
3623        node.node_id
3624    }
3625}
3626///Branded type for TupleElements non-terminal
3627#[derive(Debug, Clone)]
3628pub struct TupleElementsNode {
3629    pub(super) node_id: BuilderNodeId,
3630    pub(super) builder: CstBuilder,
3631}
3632impl TupleElementsNode {
3633    /// Consume this node and return its builder
3634    pub fn into_builder(self) -> CstBuilder {
3635        self.builder
3636    }
3637}
3638impl From<TupleElementsNode> for BuilderNodeId {
3639    fn from(node: TupleElementsNode) -> Self {
3640        node.node_id
3641    }
3642}
3643///Branded type for TupleElementsOpt non-terminal
3644#[derive(Debug, Clone)]
3645pub struct TupleElementsOptNode {
3646    pub(super) node_id: BuilderNodeId,
3647    pub(super) builder: CstBuilder,
3648}
3649impl TupleElementsOptNode {
3650    /// Consume this node and return its builder
3651    pub fn into_builder(self) -> CstBuilder {
3652        self.builder
3653    }
3654}
3655impl From<TupleElementsOptNode> for BuilderNodeId {
3656    fn from(node: TupleElementsOptNode) -> Self {
3657        node.node_id
3658    }
3659}
3660///Branded type for TupleElementsTail non-terminal
3661#[derive(Debug, Clone)]
3662pub struct TupleElementsTailNode {
3663    pub(super) node_id: BuilderNodeId,
3664    pub(super) builder: CstBuilder,
3665}
3666impl TupleElementsTailNode {
3667    /// Consume this node and return its builder
3668    pub fn into_builder(self) -> CstBuilder {
3669        self.builder
3670    }
3671}
3672impl From<TupleElementsTailNode> for BuilderNodeId {
3673    fn from(node: TupleElementsTailNode) -> Self {
3674        node.node_id
3675    }
3676}
3677///Branded type for TupleElementsTailOpt non-terminal
3678#[derive(Debug, Clone)]
3679pub struct TupleElementsTailOptNode {
3680    pub(super) node_id: BuilderNodeId,
3681    pub(super) builder: CstBuilder,
3682}
3683impl TupleElementsTailOptNode {
3684    /// Consume this node and return its builder
3685    pub fn into_builder(self) -> CstBuilder {
3686        self.builder
3687    }
3688}
3689impl From<TupleElementsTailOptNode> for BuilderNodeId {
3690    fn from(node: TupleElementsTailOptNode) -> Self {
3691        node.node_id
3692    }
3693}
3694///Branded type for TupleIndex non-terminal
3695#[derive(Debug, Clone)]
3696pub struct TupleIndexNode {
3697    pub(super) node_id: BuilderNodeId,
3698    pub(super) builder: CstBuilder,
3699}
3700impl TupleIndexNode {
3701    /// Consume this node and return its builder
3702    pub fn into_builder(self) -> CstBuilder {
3703        self.builder
3704    }
3705}
3706impl From<TupleIndexNode> for BuilderNodeId {
3707    fn from(node: TupleIndexNode) -> Self {
3708        node.node_id
3709    }
3710}
3711///Branded type for TupleOpt non-terminal
3712#[derive(Debug, Clone)]
3713pub struct TupleOptNode {
3714    pub(super) node_id: BuilderNodeId,
3715    pub(super) builder: CstBuilder,
3716}
3717impl TupleOptNode {
3718    /// Consume this node and return its builder
3719    pub fn into_builder(self) -> CstBuilder {
3720        self.builder
3721    }
3722}
3723impl From<TupleOptNode> for BuilderNodeId {
3724    fn from(node: TupleOptNode) -> Self {
3725        node.node_id
3726    }
3727}
3728///Branded type for Value non-terminal
3729#[derive(Debug, Clone)]
3730pub struct ValueNode {
3731    pub(super) node_id: BuilderNodeId,
3732    pub(super) builder: CstBuilder,
3733}
3734impl ValueNode {
3735    /// Consume this node and return its builder
3736    pub fn into_builder(self) -> CstBuilder {
3737        self.builder
3738    }
3739}
3740impl From<ValueNode> for BuilderNodeId {
3741    fn from(node: ValueNode) -> Self {
3742        node.node_id
3743    }
3744}
3745///Branded type for ValueBinding non-terminal
3746#[derive(Debug, Clone)]
3747pub struct ValueBindingNode {
3748    pub(super) node_id: BuilderNodeId,
3749    pub(super) builder: CstBuilder,
3750}
3751impl ValueBindingNode {
3752    /// Consume this node and return its builder
3753    pub fn into_builder(self) -> CstBuilder {
3754        self.builder
3755    }
3756}
3757impl From<ValueBindingNode> for BuilderNodeId {
3758    fn from(node: ValueBindingNode) -> Self {
3759        node.node_id
3760    }
3761}
3762///Branded type for Ws non-terminal
3763#[derive(Debug, Clone)]
3764pub struct WsNode {
3765    pub(super) node_id: BuilderNodeId,
3766    pub(super) builder: CstBuilder,
3767}
3768impl WsNode {
3769    /// Consume this node and return its builder
3770    pub fn into_builder(self) -> CstBuilder {
3771        self.builder
3772    }
3773}
3774impl From<WsNode> for BuilderNodeId {
3775    fn from(node: WsNode) -> Self {
3776        node.node_id
3777    }
3778}
3779///Branded type for Root non-terminal
3780#[derive(Debug, Clone)]
3781pub struct RootNode {
3782    pub(super) node_id: BuilderNodeId,
3783    pub(super) builder: CstBuilder,
3784}
3785impl RootNode {
3786    /// Consume this node and return its builder
3787    pub fn into_builder(self) -> CstBuilder {
3788        self.builder
3789    }
3790}
3791impl From<RootNode> for BuilderNodeId {
3792    fn from(node: RootNode) -> Self {
3793        node.node_id
3794    }
3795}
3796#[derive(bon::Builder)]
3797pub struct ArrayConstructor {
3798    array_begin: ArrayBeginNode,
3799    array_opt: ArrayOptNode,
3800    array_end: ArrayEndNode,
3801}
3802impl ArrayConstructor {
3803    pub fn build(self) -> ArrayNode {
3804        let mut builder = CstBuilder::new();
3805        let array_begin = builder.embed(self.array_begin.builder);
3806        let array_opt = builder.embed(self.array_opt.builder);
3807        let array_end = builder.embed(self.array_end.builder);
3808        let node_id = builder.non_terminal(
3809            NonTerminalKind::Array,
3810            vec![array_begin, array_opt, array_end],
3811        );
3812        ArrayNode { node_id, builder }
3813    }
3814}
3815#[derive(bon::Builder)]
3816pub struct ArrayBeginConstructor {
3817    l_bracket: LBracketToken,
3818}
3819impl ArrayBeginConstructor {
3820    pub fn build(self) -> ArrayBeginNode {
3821        let mut builder = CstBuilder::new();
3822        let l_bracket = builder.embed(self.l_bracket.builder);
3823        let node_id = builder.non_terminal(NonTerminalKind::ArrayBegin, vec![l_bracket]);
3824        ArrayBeginNode { node_id, builder }
3825    }
3826}
3827#[derive(bon::Builder)]
3828pub struct ArrayElementsConstructor {
3829    value: ValueNode,
3830    array_elements_opt: ArrayElementsOptNode,
3831}
3832impl ArrayElementsConstructor {
3833    pub fn build(self) -> ArrayElementsNode {
3834        let mut builder = CstBuilder::new();
3835        let value = builder.embed(self.value.builder);
3836        let array_elements_opt = builder.embed(self.array_elements_opt.builder);
3837        let node_id = builder.non_terminal(
3838            NonTerminalKind::ArrayElements,
3839            vec![value, array_elements_opt],
3840        );
3841        ArrayElementsNode { node_id, builder }
3842    }
3843}
3844#[derive(bon::Builder)]
3845pub struct ArrayElementsOptConstructor {
3846    array_elements_tail: Option<ArrayElementsTailNode>,
3847}
3848impl ArrayElementsOptConstructor {
3849    pub fn build(self) -> ArrayElementsOptNode {
3850        let mut builder = CstBuilder::new();
3851        let children = if let Some(child) = self.array_elements_tail {
3852            vec![builder.embed(child.builder)]
3853        } else {
3854            Vec::<BuilderNodeId>::new()
3855        };
3856        let node_id = builder.non_terminal(NonTerminalKind::ArrayElementsOpt, children);
3857        ArrayElementsOptNode { node_id, builder }
3858    }
3859}
3860#[derive(bon::Builder)]
3861pub struct ArrayElementsTailConstructor {
3862    comma: CommaNode,
3863    array_elements_tail_opt: ArrayElementsTailOptNode,
3864}
3865impl ArrayElementsTailConstructor {
3866    pub fn build(self) -> ArrayElementsTailNode {
3867        let mut builder = CstBuilder::new();
3868        let comma = builder.embed(self.comma.builder);
3869        let array_elements_tail_opt = builder.embed(self.array_elements_tail_opt.builder);
3870        let node_id = builder.non_terminal(
3871            NonTerminalKind::ArrayElementsTail,
3872            vec![comma, array_elements_tail_opt],
3873        );
3874        ArrayElementsTailNode { node_id, builder }
3875    }
3876}
3877#[derive(bon::Builder)]
3878pub struct ArrayElementsTailOptConstructor {
3879    array_elements: Option<ArrayElementsNode>,
3880}
3881impl ArrayElementsTailOptConstructor {
3882    pub fn build(self) -> ArrayElementsTailOptNode {
3883        let mut builder = CstBuilder::new();
3884        let children = if let Some(child) = self.array_elements {
3885            vec![builder.embed(child.builder)]
3886        } else {
3887            Vec::<BuilderNodeId>::new()
3888        };
3889        let node_id = builder.non_terminal(NonTerminalKind::ArrayElementsTailOpt, children);
3890        ArrayElementsTailOptNode { node_id, builder }
3891    }
3892}
3893#[derive(bon::Builder)]
3894pub struct ArrayEndConstructor {
3895    r_bracket: RBracketToken,
3896}
3897impl ArrayEndConstructor {
3898    pub fn build(self) -> ArrayEndNode {
3899        let mut builder = CstBuilder::new();
3900        let r_bracket = builder.embed(self.r_bracket.builder);
3901        let node_id = builder.non_terminal(NonTerminalKind::ArrayEnd, vec![r_bracket]);
3902        ArrayEndNode { node_id, builder }
3903    }
3904}
3905#[derive(bon::Builder)]
3906pub struct ArrayMarkerConstructor {
3907    array_begin: ArrayBeginNode,
3908    array_marker_opt: ArrayMarkerOptNode,
3909    array_end: ArrayEndNode,
3910}
3911impl ArrayMarkerConstructor {
3912    pub fn build(self) -> ArrayMarkerNode {
3913        let mut builder = CstBuilder::new();
3914        let array_begin = builder.embed(self.array_begin.builder);
3915        let array_marker_opt = builder.embed(self.array_marker_opt.builder);
3916        let array_end = builder.embed(self.array_end.builder);
3917        let node_id = builder.non_terminal(
3918            NonTerminalKind::ArrayMarker,
3919            vec![array_begin, array_marker_opt, array_end],
3920        );
3921        ArrayMarkerNode { node_id, builder }
3922    }
3923}
3924#[derive(bon::Builder)]
3925pub struct ArrayMarkerOptConstructor {
3926    integer: Option<IntegerNode>,
3927}
3928impl ArrayMarkerOptConstructor {
3929    pub fn build(self) -> ArrayMarkerOptNode {
3930        let mut builder = CstBuilder::new();
3931        let children = if let Some(child) = self.integer {
3932            vec![builder.embed(child.builder)]
3933        } else {
3934            Vec::<BuilderNodeId>::new()
3935        };
3936        let node_id = builder.non_terminal(NonTerminalKind::ArrayMarkerOpt, children);
3937        ArrayMarkerOptNode { node_id, builder }
3938    }
3939}
3940#[derive(bon::Builder)]
3941pub struct ArrayOptConstructor {
3942    array_elements: Option<ArrayElementsNode>,
3943}
3944impl ArrayOptConstructor {
3945    pub fn build(self) -> ArrayOptNode {
3946        let mut builder = CstBuilder::new();
3947        let children = if let Some(child) = self.array_elements {
3948            vec![builder.embed(child.builder)]
3949        } else {
3950            Vec::<BuilderNodeId>::new()
3951        };
3952        let node_id = builder.non_terminal(NonTerminalKind::ArrayOpt, children);
3953        ArrayOptNode { node_id, builder }
3954    }
3955}
3956#[derive(bon::Builder)]
3957pub struct AtConstructor {
3958    at: AtToken,
3959}
3960impl AtConstructor {
3961    pub fn build(self) -> AtNode {
3962        let mut builder = CstBuilder::new();
3963        let at = builder.embed(self.at.builder);
3964        let node_id = builder.non_terminal(NonTerminalKind::At, vec![at]);
3965        AtNode { node_id, builder }
3966    }
3967}
3968#[derive(bon::Builder)]
3969pub struct Backtick2Constructor {
3970    backtick_2: Backtick2Token,
3971}
3972impl Backtick2Constructor {
3973    pub fn build(self) -> Backtick2Node {
3974        let mut builder = CstBuilder::new();
3975        let backtick_2 = builder.embed(self.backtick_2.builder);
3976        let node_id = builder.non_terminal(NonTerminalKind::Backtick2, vec![backtick_2]);
3977        Backtick2Node { node_id, builder }
3978    }
3979}
3980#[derive(bon::Builder)]
3981pub struct Backtick3Constructor {
3982    backtick_3: Backtick3Token,
3983}
3984impl Backtick3Constructor {
3985    pub fn build(self) -> Backtick3Node {
3986        let mut builder = CstBuilder::new();
3987        let backtick_3 = builder.embed(self.backtick_3.builder);
3988        let node_id = builder.non_terminal(NonTerminalKind::Backtick3, vec![backtick_3]);
3989        Backtick3Node { node_id, builder }
3990    }
3991}
3992#[derive(bon::Builder)]
3993pub struct Backtick4Constructor {
3994    backtick_4: Backtick4Token,
3995}
3996impl Backtick4Constructor {
3997    pub fn build(self) -> Backtick4Node {
3998        let mut builder = CstBuilder::new();
3999        let backtick_4 = builder.embed(self.backtick_4.builder);
4000        let node_id = builder.non_terminal(NonTerminalKind::Backtick4, vec![backtick_4]);
4001        Backtick4Node { node_id, builder }
4002    }
4003}
4004#[derive(bon::Builder)]
4005pub struct Backtick5Constructor {
4006    backtick_5: Backtick5Token,
4007}
4008impl Backtick5Constructor {
4009    pub fn build(self) -> Backtick5Node {
4010        let mut builder = CstBuilder::new();
4011        let backtick_5 = builder.embed(self.backtick_5.builder);
4012        let node_id = builder.non_terminal(NonTerminalKind::Backtick5, vec![backtick_5]);
4013        Backtick5Node { node_id, builder }
4014    }
4015}
4016#[derive(bon::Builder)]
4017pub struct BacktickDelimConstructor {
4018    backtick_delim: BacktickDelimToken,
4019}
4020impl BacktickDelimConstructor {
4021    pub fn build(self) -> BacktickDelimNode {
4022        let mut builder = CstBuilder::new();
4023        let backtick_delim = builder.embed(self.backtick_delim.builder);
4024        let node_id = builder.non_terminal(NonTerminalKind::BacktickDelim, vec![backtick_delim]);
4025        BacktickDelimNode { node_id, builder }
4026    }
4027}
4028#[derive(bon::Builder)]
4029pub struct BeginConstructor {
4030    l_brace: LBraceToken,
4031}
4032impl BeginConstructor {
4033    pub fn build(self) -> BeginNode {
4034        let mut builder = CstBuilder::new();
4035        let l_brace = builder.embed(self.l_brace.builder);
4036        let node_id = builder.non_terminal(NonTerminalKind::Begin, vec![l_brace]);
4037        BeginNode { node_id, builder }
4038    }
4039}
4040#[derive(bon::Builder)]
4041pub struct BindConstructor {
4042    bind: BindToken,
4043}
4044impl BindConstructor {
4045    pub fn build(self) -> BindNode {
4046        let mut builder = CstBuilder::new();
4047        let bind = builder.embed(self.bind.builder);
4048        let node_id = builder.non_terminal(NonTerminalKind::Bind, vec![bind]);
4049        BindNode { node_id, builder }
4050    }
4051}
4052#[derive(bon::Builder)]
4053pub struct BindingConstructor {
4054    keys: KeysNode,
4055    binding_rhs: BindingRhsNode,
4056}
4057impl BindingConstructor {
4058    pub fn build(self) -> BindingNode {
4059        let mut builder = CstBuilder::new();
4060        let keys = builder.embed(self.keys.builder);
4061        let binding_rhs = builder.embed(self.binding_rhs.builder);
4062        let node_id = builder.non_terminal(NonTerminalKind::Binding, vec![keys, binding_rhs]);
4063        BindingNode { node_id, builder }
4064    }
4065}
4066pub enum BindingRhsConstructor {
4067    ValueBinding(ValueBindingNode),
4068    SectionBinding(SectionBindingNode),
4069    TextBinding(TextBindingNode),
4070}
4071impl BindingRhsConstructor {
4072    pub fn build(self) -> BindingRhsNode {
4073        let mut builder = CstBuilder::new();
4074        let child_id = match self {
4075            Self::ValueBinding(node) => builder.embed(node.builder),
4076            Self::SectionBinding(node) => builder.embed(node.builder),
4077            Self::TextBinding(node) => builder.embed(node.builder),
4078        };
4079        let node_id = builder.non_terminal(NonTerminalKind::BindingRhs, vec![child_id]);
4080        BindingRhsNode { node_id, builder }
4081    }
4082}
4083#[derive(bon::Builder)]
4084pub struct BlockBodyConstructor {
4085    begin: BeginNode,
4086    eure: EureNode,
4087    end: EndNode,
4088}
4089impl BlockBodyConstructor {
4090    pub fn build(self) -> BlockBodyNode {
4091        let mut builder = CstBuilder::new();
4092        let begin = builder.embed(self.begin.builder);
4093        let eure = builder.embed(self.eure.builder);
4094        let end = builder.embed(self.end.builder);
4095        let node_id = builder.non_terminal(NonTerminalKind::BlockBody, vec![begin, eure, end]);
4096        BlockBodyNode { node_id, builder }
4097    }
4098}
4099pub enum BooleanConstructor {
4100    True(TrueNode),
4101    False(FalseNode),
4102}
4103impl BooleanConstructor {
4104    pub fn build(self) -> BooleanNode {
4105        let mut builder = CstBuilder::new();
4106        let child_id = match self {
4107            Self::True(node) => builder.embed(node.builder),
4108            Self::False(node) => builder.embed(node.builder),
4109        };
4110        let node_id = builder.non_terminal(NonTerminalKind::Boolean, vec![child_id]);
4111        BooleanNode { node_id, builder }
4112    }
4113}
4114pub enum CodeBlockConstructor {
4115    CodeBlock3(CodeBlock3Node),
4116    CodeBlock4(CodeBlock4Node),
4117    CodeBlock5(CodeBlock5Node),
4118    CodeBlock6(CodeBlock6Node),
4119}
4120impl CodeBlockConstructor {
4121    pub fn build(self) -> CodeBlockNode {
4122        let mut builder = CstBuilder::new();
4123        let child_id = match self {
4124            Self::CodeBlock3(node) => builder.embed(node.builder),
4125            Self::CodeBlock4(node) => builder.embed(node.builder),
4126            Self::CodeBlock5(node) => builder.embed(node.builder),
4127            Self::CodeBlock6(node) => builder.embed(node.builder),
4128        };
4129        let node_id = builder.non_terminal(NonTerminalKind::CodeBlock, vec![child_id]);
4130        CodeBlockNode { node_id, builder }
4131    }
4132}
4133#[derive(bon::Builder)]
4134pub struct CodeBlock3Constructor {
4135    code_block_start_3: CodeBlockStart3Node,
4136    code_block_3_list: CodeBlock3ListNode,
4137    code_block_end_3: CodeBlockEnd3Node,
4138}
4139impl CodeBlock3Constructor {
4140    pub fn build(self) -> CodeBlock3Node {
4141        let mut builder = CstBuilder::new();
4142        let code_block_start_3 = builder.embed(self.code_block_start_3.builder);
4143        let code_block_3_list = builder.embed(self.code_block_3_list.builder);
4144        let code_block_end_3 = builder.embed(self.code_block_end_3.builder);
4145        let node_id = builder.non_terminal(
4146            NonTerminalKind::CodeBlock3,
4147            vec![code_block_start_3, code_block_3_list, code_block_end_3],
4148        );
4149        CodeBlock3Node { node_id, builder }
4150    }
4151}
4152#[derive(bon::Builder)]
4153pub struct CodeBlock3ListConstructor {
4154    code_block_3_list_group: CodeBlock3ListGroupNode,
4155    code_block_3_list: CodeBlock3ListNode,
4156}
4157impl CodeBlock3ListConstructor {
4158    /// Create an empty node (base case for recursion)
4159    pub fn empty() -> CodeBlock3ListNode {
4160        let mut builder = CstBuilder::new();
4161        let node_id =
4162            builder.non_terminal(NonTerminalKind::CodeBlock3List, Vec::<BuilderNodeId>::new());
4163        CodeBlock3ListNode { node_id, builder }
4164    }
4165    /// Create a node with children (recursive case)
4166    pub fn build(self) -> CodeBlock3ListNode {
4167        let mut builder = CstBuilder::new();
4168        let code_block_3_list_group = builder.embed(self.code_block_3_list_group.builder);
4169        let code_block_3_list = builder.embed(self.code_block_3_list.builder);
4170        let node_id = builder.non_terminal(
4171            NonTerminalKind::CodeBlock3List,
4172            vec![code_block_3_list_group, code_block_3_list],
4173        );
4174        CodeBlock3ListNode { node_id, builder }
4175    }
4176}
4177pub enum CodeBlock3ListGroupConstructor {
4178    NoBacktick(NoBacktickNode),
4179    Backtick2(Backtick2Node),
4180}
4181impl CodeBlock3ListGroupConstructor {
4182    pub fn build(self) -> CodeBlock3ListGroupNode {
4183        let mut builder = CstBuilder::new();
4184        let child_id = match self {
4185            Self::NoBacktick(node) => builder.embed(node.builder),
4186            Self::Backtick2(node) => builder.embed(node.builder),
4187        };
4188        let node_id = builder.non_terminal(NonTerminalKind::CodeBlock3ListGroup, vec![child_id]);
4189        CodeBlock3ListGroupNode { node_id, builder }
4190    }
4191}
4192#[derive(bon::Builder)]
4193pub struct CodeBlock4Constructor {
4194    code_block_start_4: CodeBlockStart4Node,
4195    code_block_4_list: CodeBlock4ListNode,
4196    code_block_end_4: CodeBlockEnd4Node,
4197}
4198impl CodeBlock4Constructor {
4199    pub fn build(self) -> CodeBlock4Node {
4200        let mut builder = CstBuilder::new();
4201        let code_block_start_4 = builder.embed(self.code_block_start_4.builder);
4202        let code_block_4_list = builder.embed(self.code_block_4_list.builder);
4203        let code_block_end_4 = builder.embed(self.code_block_end_4.builder);
4204        let node_id = builder.non_terminal(
4205            NonTerminalKind::CodeBlock4,
4206            vec![code_block_start_4, code_block_4_list, code_block_end_4],
4207        );
4208        CodeBlock4Node { node_id, builder }
4209    }
4210}
4211#[derive(bon::Builder)]
4212pub struct CodeBlock4ListConstructor {
4213    code_block_4_list_group: CodeBlock4ListGroupNode,
4214    code_block_4_list: CodeBlock4ListNode,
4215}
4216impl CodeBlock4ListConstructor {
4217    /// Create an empty node (base case for recursion)
4218    pub fn empty() -> CodeBlock4ListNode {
4219        let mut builder = CstBuilder::new();
4220        let node_id =
4221            builder.non_terminal(NonTerminalKind::CodeBlock4List, Vec::<BuilderNodeId>::new());
4222        CodeBlock4ListNode { node_id, builder }
4223    }
4224    /// Create a node with children (recursive case)
4225    pub fn build(self) -> CodeBlock4ListNode {
4226        let mut builder = CstBuilder::new();
4227        let code_block_4_list_group = builder.embed(self.code_block_4_list_group.builder);
4228        let code_block_4_list = builder.embed(self.code_block_4_list.builder);
4229        let node_id = builder.non_terminal(
4230            NonTerminalKind::CodeBlock4List,
4231            vec![code_block_4_list_group, code_block_4_list],
4232        );
4233        CodeBlock4ListNode { node_id, builder }
4234    }
4235}
4236pub enum CodeBlock4ListGroupConstructor {
4237    NoBacktick(NoBacktickNode),
4238    Backtick3(Backtick3Node),
4239}
4240impl CodeBlock4ListGroupConstructor {
4241    pub fn build(self) -> CodeBlock4ListGroupNode {
4242        let mut builder = CstBuilder::new();
4243        let child_id = match self {
4244            Self::NoBacktick(node) => builder.embed(node.builder),
4245            Self::Backtick3(node) => builder.embed(node.builder),
4246        };
4247        let node_id = builder.non_terminal(NonTerminalKind::CodeBlock4ListGroup, vec![child_id]);
4248        CodeBlock4ListGroupNode { node_id, builder }
4249    }
4250}
4251#[derive(bon::Builder)]
4252pub struct CodeBlock5Constructor {
4253    code_block_start_5: CodeBlockStart5Node,
4254    code_block_5_list: CodeBlock5ListNode,
4255    code_block_end_5: CodeBlockEnd5Node,
4256}
4257impl CodeBlock5Constructor {
4258    pub fn build(self) -> CodeBlock5Node {
4259        let mut builder = CstBuilder::new();
4260        let code_block_start_5 = builder.embed(self.code_block_start_5.builder);
4261        let code_block_5_list = builder.embed(self.code_block_5_list.builder);
4262        let code_block_end_5 = builder.embed(self.code_block_end_5.builder);
4263        let node_id = builder.non_terminal(
4264            NonTerminalKind::CodeBlock5,
4265            vec![code_block_start_5, code_block_5_list, code_block_end_5],
4266        );
4267        CodeBlock5Node { node_id, builder }
4268    }
4269}
4270#[derive(bon::Builder)]
4271pub struct CodeBlock5ListConstructor {
4272    code_block_5_list_group: CodeBlock5ListGroupNode,
4273    code_block_5_list: CodeBlock5ListNode,
4274}
4275impl CodeBlock5ListConstructor {
4276    /// Create an empty node (base case for recursion)
4277    pub fn empty() -> CodeBlock5ListNode {
4278        let mut builder = CstBuilder::new();
4279        let node_id =
4280            builder.non_terminal(NonTerminalKind::CodeBlock5List, Vec::<BuilderNodeId>::new());
4281        CodeBlock5ListNode { node_id, builder }
4282    }
4283    /// Create a node with children (recursive case)
4284    pub fn build(self) -> CodeBlock5ListNode {
4285        let mut builder = CstBuilder::new();
4286        let code_block_5_list_group = builder.embed(self.code_block_5_list_group.builder);
4287        let code_block_5_list = builder.embed(self.code_block_5_list.builder);
4288        let node_id = builder.non_terminal(
4289            NonTerminalKind::CodeBlock5List,
4290            vec![code_block_5_list_group, code_block_5_list],
4291        );
4292        CodeBlock5ListNode { node_id, builder }
4293    }
4294}
4295pub enum CodeBlock5ListGroupConstructor {
4296    NoBacktick(NoBacktickNode),
4297    Backtick4(Backtick4Node),
4298}
4299impl CodeBlock5ListGroupConstructor {
4300    pub fn build(self) -> CodeBlock5ListGroupNode {
4301        let mut builder = CstBuilder::new();
4302        let child_id = match self {
4303            Self::NoBacktick(node) => builder.embed(node.builder),
4304            Self::Backtick4(node) => builder.embed(node.builder),
4305        };
4306        let node_id = builder.non_terminal(NonTerminalKind::CodeBlock5ListGroup, vec![child_id]);
4307        CodeBlock5ListGroupNode { node_id, builder }
4308    }
4309}
4310#[derive(bon::Builder)]
4311pub struct CodeBlock6Constructor {
4312    code_block_start_6: CodeBlockStart6Node,
4313    code_block_6_list: CodeBlock6ListNode,
4314    code_block_end_6: CodeBlockEnd6Node,
4315}
4316impl CodeBlock6Constructor {
4317    pub fn build(self) -> CodeBlock6Node {
4318        let mut builder = CstBuilder::new();
4319        let code_block_start_6 = builder.embed(self.code_block_start_6.builder);
4320        let code_block_6_list = builder.embed(self.code_block_6_list.builder);
4321        let code_block_end_6 = builder.embed(self.code_block_end_6.builder);
4322        let node_id = builder.non_terminal(
4323            NonTerminalKind::CodeBlock6,
4324            vec![code_block_start_6, code_block_6_list, code_block_end_6],
4325        );
4326        CodeBlock6Node { node_id, builder }
4327    }
4328}
4329#[derive(bon::Builder)]
4330pub struct CodeBlock6ListConstructor {
4331    code_block_6_list_group: CodeBlock6ListGroupNode,
4332    code_block_6_list: CodeBlock6ListNode,
4333}
4334impl CodeBlock6ListConstructor {
4335    /// Create an empty node (base case for recursion)
4336    pub fn empty() -> CodeBlock6ListNode {
4337        let mut builder = CstBuilder::new();
4338        let node_id =
4339            builder.non_terminal(NonTerminalKind::CodeBlock6List, Vec::<BuilderNodeId>::new());
4340        CodeBlock6ListNode { node_id, builder }
4341    }
4342    /// Create a node with children (recursive case)
4343    pub fn build(self) -> CodeBlock6ListNode {
4344        let mut builder = CstBuilder::new();
4345        let code_block_6_list_group = builder.embed(self.code_block_6_list_group.builder);
4346        let code_block_6_list = builder.embed(self.code_block_6_list.builder);
4347        let node_id = builder.non_terminal(
4348            NonTerminalKind::CodeBlock6List,
4349            vec![code_block_6_list_group, code_block_6_list],
4350        );
4351        CodeBlock6ListNode { node_id, builder }
4352    }
4353}
4354pub enum CodeBlock6ListGroupConstructor {
4355    NoBacktick(NoBacktickNode),
4356    Backtick5(Backtick5Node),
4357}
4358impl CodeBlock6ListGroupConstructor {
4359    pub fn build(self) -> CodeBlock6ListGroupNode {
4360        let mut builder = CstBuilder::new();
4361        let child_id = match self {
4362            Self::NoBacktick(node) => builder.embed(node.builder),
4363            Self::Backtick5(node) => builder.embed(node.builder),
4364        };
4365        let node_id = builder.non_terminal(NonTerminalKind::CodeBlock6ListGroup, vec![child_id]);
4366        CodeBlock6ListGroupNode { node_id, builder }
4367    }
4368}
4369#[derive(bon::Builder)]
4370pub struct CodeBlockEnd3Constructor {
4371    code_block_end_3: CodeBlockEnd3Token,
4372}
4373impl CodeBlockEnd3Constructor {
4374    pub fn build(self) -> CodeBlockEnd3Node {
4375        let mut builder = CstBuilder::new();
4376        let code_block_end_3 = builder.embed(self.code_block_end_3.builder);
4377        let node_id = builder.non_terminal(NonTerminalKind::CodeBlockEnd3, vec![code_block_end_3]);
4378        CodeBlockEnd3Node { node_id, builder }
4379    }
4380}
4381#[derive(bon::Builder)]
4382pub struct CodeBlockEnd4Constructor {
4383    code_block_end_4: CodeBlockEnd4Token,
4384}
4385impl CodeBlockEnd4Constructor {
4386    pub fn build(self) -> CodeBlockEnd4Node {
4387        let mut builder = CstBuilder::new();
4388        let code_block_end_4 = builder.embed(self.code_block_end_4.builder);
4389        let node_id = builder.non_terminal(NonTerminalKind::CodeBlockEnd4, vec![code_block_end_4]);
4390        CodeBlockEnd4Node { node_id, builder }
4391    }
4392}
4393#[derive(bon::Builder)]
4394pub struct CodeBlockEnd5Constructor {
4395    code_block_end_5: CodeBlockEnd5Token,
4396}
4397impl CodeBlockEnd5Constructor {
4398    pub fn build(self) -> CodeBlockEnd5Node {
4399        let mut builder = CstBuilder::new();
4400        let code_block_end_5 = builder.embed(self.code_block_end_5.builder);
4401        let node_id = builder.non_terminal(NonTerminalKind::CodeBlockEnd5, vec![code_block_end_5]);
4402        CodeBlockEnd5Node { node_id, builder }
4403    }
4404}
4405#[derive(bon::Builder)]
4406pub struct CodeBlockEnd6Constructor {
4407    code_block_end_6: CodeBlockEnd6Token,
4408}
4409impl CodeBlockEnd6Constructor {
4410    pub fn build(self) -> CodeBlockEnd6Node {
4411        let mut builder = CstBuilder::new();
4412        let code_block_end_6 = builder.embed(self.code_block_end_6.builder);
4413        let node_id = builder.non_terminal(NonTerminalKind::CodeBlockEnd6, vec![code_block_end_6]);
4414        CodeBlockEnd6Node { node_id, builder }
4415    }
4416}
4417#[derive(bon::Builder)]
4418pub struct CodeBlockStart3Constructor {
4419    code_block_start_3: CodeBlockStart3Token,
4420}
4421impl CodeBlockStart3Constructor {
4422    pub fn build(self) -> CodeBlockStart3Node {
4423        let mut builder = CstBuilder::new();
4424        let code_block_start_3 = builder.embed(self.code_block_start_3.builder);
4425        let node_id =
4426            builder.non_terminal(NonTerminalKind::CodeBlockStart3, vec![code_block_start_3]);
4427        CodeBlockStart3Node { node_id, builder }
4428    }
4429}
4430#[derive(bon::Builder)]
4431pub struct CodeBlockStart4Constructor {
4432    code_block_start_4: CodeBlockStart4Token,
4433}
4434impl CodeBlockStart4Constructor {
4435    pub fn build(self) -> CodeBlockStart4Node {
4436        let mut builder = CstBuilder::new();
4437        let code_block_start_4 = builder.embed(self.code_block_start_4.builder);
4438        let node_id =
4439            builder.non_terminal(NonTerminalKind::CodeBlockStart4, vec![code_block_start_4]);
4440        CodeBlockStart4Node { node_id, builder }
4441    }
4442}
4443#[derive(bon::Builder)]
4444pub struct CodeBlockStart5Constructor {
4445    code_block_start_5: CodeBlockStart5Token,
4446}
4447impl CodeBlockStart5Constructor {
4448    pub fn build(self) -> CodeBlockStart5Node {
4449        let mut builder = CstBuilder::new();
4450        let code_block_start_5 = builder.embed(self.code_block_start_5.builder);
4451        let node_id =
4452            builder.non_terminal(NonTerminalKind::CodeBlockStart5, vec![code_block_start_5]);
4453        CodeBlockStart5Node { node_id, builder }
4454    }
4455}
4456#[derive(bon::Builder)]
4457pub struct CodeBlockStart6Constructor {
4458    code_block_start_6: CodeBlockStart6Token,
4459}
4460impl CodeBlockStart6Constructor {
4461    pub fn build(self) -> CodeBlockStart6Node {
4462        let mut builder = CstBuilder::new();
4463        let code_block_start_6 = builder.embed(self.code_block_start_6.builder);
4464        let node_id =
4465            builder.non_terminal(NonTerminalKind::CodeBlockStart6, vec![code_block_start_6]);
4466        CodeBlockStart6Node { node_id, builder }
4467    }
4468}
4469#[derive(bon::Builder)]
4470pub struct CommaConstructor {
4471    comma: CommaToken,
4472}
4473impl CommaConstructor {
4474    pub fn build(self) -> CommaNode {
4475        let mut builder = CstBuilder::new();
4476        let comma = builder.embed(self.comma.builder);
4477        let node_id = builder.non_terminal(NonTerminalKind::Comma, vec![comma]);
4478        CommaNode { node_id, builder }
4479    }
4480}
4481#[derive(bon::Builder)]
4482pub struct ContinueConstructor {
4483    esc: EscToken,
4484}
4485impl ContinueConstructor {
4486    pub fn build(self) -> ContinueNode {
4487        let mut builder = CstBuilder::new();
4488        let esc = builder.embed(self.esc.builder);
4489        let node_id = builder.non_terminal(NonTerminalKind::Continue, vec![esc]);
4490        ContinueNode { node_id, builder }
4491    }
4492}
4493pub enum DelimCodeConstructor {
4494    DelimCode3(DelimCode3Node),
4495    DelimCode2(DelimCode2Node),
4496    DelimCode1(DelimCode1Node),
4497}
4498impl DelimCodeConstructor {
4499    pub fn build(self) -> DelimCodeNode {
4500        let mut builder = CstBuilder::new();
4501        let child_id = match self {
4502            Self::DelimCode3(node) => builder.embed(node.builder),
4503            Self::DelimCode2(node) => builder.embed(node.builder),
4504            Self::DelimCode1(node) => builder.embed(node.builder),
4505        };
4506        let node_id = builder.non_terminal(NonTerminalKind::DelimCode, vec![child_id]);
4507        DelimCodeNode { node_id, builder }
4508    }
4509}
4510#[derive(bon::Builder)]
4511pub struct DelimCode1Constructor {
4512    delim_code_start_1: DelimCodeStart1Node,
4513    delim_code_1_list: DelimCode1ListNode,
4514    delim_code_end_1: DelimCodeEnd1Node,
4515}
4516impl DelimCode1Constructor {
4517    pub fn build(self) -> DelimCode1Node {
4518        let mut builder = CstBuilder::new();
4519        let delim_code_start_1 = builder.embed(self.delim_code_start_1.builder);
4520        let delim_code_1_list = builder.embed(self.delim_code_1_list.builder);
4521        let delim_code_end_1 = builder.embed(self.delim_code_end_1.builder);
4522        let node_id = builder.non_terminal(
4523            NonTerminalKind::DelimCode1,
4524            vec![delim_code_start_1, delim_code_1_list, delim_code_end_1],
4525        );
4526        DelimCode1Node { node_id, builder }
4527    }
4528}
4529#[derive(bon::Builder)]
4530pub struct DelimCode1ListConstructor {
4531    delim_code_1_list_group: DelimCode1ListGroupNode,
4532    delim_code_1_list: DelimCode1ListNode,
4533}
4534impl DelimCode1ListConstructor {
4535    /// Create an empty node (base case for recursion)
4536    pub fn empty() -> DelimCode1ListNode {
4537        let mut builder = CstBuilder::new();
4538        let node_id =
4539            builder.non_terminal(NonTerminalKind::DelimCode1List, Vec::<BuilderNodeId>::new());
4540        DelimCode1ListNode { node_id, builder }
4541    }
4542    /// Create a node with children (recursive case)
4543    pub fn build(self) -> DelimCode1ListNode {
4544        let mut builder = CstBuilder::new();
4545        let delim_code_1_list_group = builder.embed(self.delim_code_1_list_group.builder);
4546        let delim_code_1_list = builder.embed(self.delim_code_1_list.builder);
4547        let node_id = builder.non_terminal(
4548            NonTerminalKind::DelimCode1List,
4549            vec![delim_code_1_list_group, delim_code_1_list],
4550        );
4551        DelimCode1ListNode { node_id, builder }
4552    }
4553}
4554pub enum DelimCode1ListGroupConstructor {
4555    NoBacktick(NoBacktickNode),
4556    BacktickDelim(BacktickDelimNode),
4557}
4558impl DelimCode1ListGroupConstructor {
4559    pub fn build(self) -> DelimCode1ListGroupNode {
4560        let mut builder = CstBuilder::new();
4561        let child_id = match self {
4562            Self::NoBacktick(node) => builder.embed(node.builder),
4563            Self::BacktickDelim(node) => builder.embed(node.builder),
4564        };
4565        let node_id = builder.non_terminal(NonTerminalKind::DelimCode1ListGroup, vec![child_id]);
4566        DelimCode1ListGroupNode { node_id, builder }
4567    }
4568}
4569#[derive(bon::Builder)]
4570pub struct DelimCode2Constructor {
4571    delim_code_start_2: DelimCodeStart2Node,
4572    delim_code_2_list: DelimCode2ListNode,
4573    delim_code_end_2: DelimCodeEnd2Node,
4574}
4575impl DelimCode2Constructor {
4576    pub fn build(self) -> DelimCode2Node {
4577        let mut builder = CstBuilder::new();
4578        let delim_code_start_2 = builder.embed(self.delim_code_start_2.builder);
4579        let delim_code_2_list = builder.embed(self.delim_code_2_list.builder);
4580        let delim_code_end_2 = builder.embed(self.delim_code_end_2.builder);
4581        let node_id = builder.non_terminal(
4582            NonTerminalKind::DelimCode2,
4583            vec![delim_code_start_2, delim_code_2_list, delim_code_end_2],
4584        );
4585        DelimCode2Node { node_id, builder }
4586    }
4587}
4588#[derive(bon::Builder)]
4589pub struct DelimCode2ListConstructor {
4590    delim_code_2_list_group: DelimCode2ListGroupNode,
4591    delim_code_2_list: DelimCode2ListNode,
4592}
4593impl DelimCode2ListConstructor {
4594    /// Create an empty node (base case for recursion)
4595    pub fn empty() -> DelimCode2ListNode {
4596        let mut builder = CstBuilder::new();
4597        let node_id =
4598            builder.non_terminal(NonTerminalKind::DelimCode2List, Vec::<BuilderNodeId>::new());
4599        DelimCode2ListNode { node_id, builder }
4600    }
4601    /// Create a node with children (recursive case)
4602    pub fn build(self) -> DelimCode2ListNode {
4603        let mut builder = CstBuilder::new();
4604        let delim_code_2_list_group = builder.embed(self.delim_code_2_list_group.builder);
4605        let delim_code_2_list = builder.embed(self.delim_code_2_list.builder);
4606        let node_id = builder.non_terminal(
4607            NonTerminalKind::DelimCode2List,
4608            vec![delim_code_2_list_group, delim_code_2_list],
4609        );
4610        DelimCode2ListNode { node_id, builder }
4611    }
4612}
4613pub enum DelimCode2ListGroupConstructor {
4614    NoBacktick(NoBacktickNode),
4615    BacktickDelim(BacktickDelimNode),
4616}
4617impl DelimCode2ListGroupConstructor {
4618    pub fn build(self) -> DelimCode2ListGroupNode {
4619        let mut builder = CstBuilder::new();
4620        let child_id = match self {
4621            Self::NoBacktick(node) => builder.embed(node.builder),
4622            Self::BacktickDelim(node) => builder.embed(node.builder),
4623        };
4624        let node_id = builder.non_terminal(NonTerminalKind::DelimCode2ListGroup, vec![child_id]);
4625        DelimCode2ListGroupNode { node_id, builder }
4626    }
4627}
4628#[derive(bon::Builder)]
4629pub struct DelimCode3Constructor {
4630    delim_code_start_3: DelimCodeStart3Node,
4631    delim_code_3_list: DelimCode3ListNode,
4632    delim_code_end_3: DelimCodeEnd3Node,
4633}
4634impl DelimCode3Constructor {
4635    pub fn build(self) -> DelimCode3Node {
4636        let mut builder = CstBuilder::new();
4637        let delim_code_start_3 = builder.embed(self.delim_code_start_3.builder);
4638        let delim_code_3_list = builder.embed(self.delim_code_3_list.builder);
4639        let delim_code_end_3 = builder.embed(self.delim_code_end_3.builder);
4640        let node_id = builder.non_terminal(
4641            NonTerminalKind::DelimCode3,
4642            vec![delim_code_start_3, delim_code_3_list, delim_code_end_3],
4643        );
4644        DelimCode3Node { node_id, builder }
4645    }
4646}
4647#[derive(bon::Builder)]
4648pub struct DelimCode3ListConstructor {
4649    delim_code_3_list_group: DelimCode3ListGroupNode,
4650    delim_code_3_list: DelimCode3ListNode,
4651}
4652impl DelimCode3ListConstructor {
4653    /// Create an empty node (base case for recursion)
4654    pub fn empty() -> DelimCode3ListNode {
4655        let mut builder = CstBuilder::new();
4656        let node_id =
4657            builder.non_terminal(NonTerminalKind::DelimCode3List, Vec::<BuilderNodeId>::new());
4658        DelimCode3ListNode { node_id, builder }
4659    }
4660    /// Create a node with children (recursive case)
4661    pub fn build(self) -> DelimCode3ListNode {
4662        let mut builder = CstBuilder::new();
4663        let delim_code_3_list_group = builder.embed(self.delim_code_3_list_group.builder);
4664        let delim_code_3_list = builder.embed(self.delim_code_3_list.builder);
4665        let node_id = builder.non_terminal(
4666            NonTerminalKind::DelimCode3List,
4667            vec![delim_code_3_list_group, delim_code_3_list],
4668        );
4669        DelimCode3ListNode { node_id, builder }
4670    }
4671}
4672pub enum DelimCode3ListGroupConstructor {
4673    NoBacktick(NoBacktickNode),
4674    BacktickDelim(BacktickDelimNode),
4675}
4676impl DelimCode3ListGroupConstructor {
4677    pub fn build(self) -> DelimCode3ListGroupNode {
4678        let mut builder = CstBuilder::new();
4679        let child_id = match self {
4680            Self::NoBacktick(node) => builder.embed(node.builder),
4681            Self::BacktickDelim(node) => builder.embed(node.builder),
4682        };
4683        let node_id = builder.non_terminal(NonTerminalKind::DelimCode3ListGroup, vec![child_id]);
4684        DelimCode3ListGroupNode { node_id, builder }
4685    }
4686}
4687#[derive(bon::Builder)]
4688pub struct DelimCodeEnd1Constructor {
4689    delim_code_end_1: DelimCodeEnd1Token,
4690}
4691impl DelimCodeEnd1Constructor {
4692    pub fn build(self) -> DelimCodeEnd1Node {
4693        let mut builder = CstBuilder::new();
4694        let delim_code_end_1 = builder.embed(self.delim_code_end_1.builder);
4695        let node_id = builder.non_terminal(NonTerminalKind::DelimCodeEnd1, vec![delim_code_end_1]);
4696        DelimCodeEnd1Node { node_id, builder }
4697    }
4698}
4699#[derive(bon::Builder)]
4700pub struct DelimCodeEnd2Constructor {
4701    delim_code_end_2: DelimCodeEnd2Token,
4702}
4703impl DelimCodeEnd2Constructor {
4704    pub fn build(self) -> DelimCodeEnd2Node {
4705        let mut builder = CstBuilder::new();
4706        let delim_code_end_2 = builder.embed(self.delim_code_end_2.builder);
4707        let node_id = builder.non_terminal(NonTerminalKind::DelimCodeEnd2, vec![delim_code_end_2]);
4708        DelimCodeEnd2Node { node_id, builder }
4709    }
4710}
4711#[derive(bon::Builder)]
4712pub struct DelimCodeEnd3Constructor {
4713    delim_code_end_3: DelimCodeEnd3Token,
4714}
4715impl DelimCodeEnd3Constructor {
4716    pub fn build(self) -> DelimCodeEnd3Node {
4717        let mut builder = CstBuilder::new();
4718        let delim_code_end_3 = builder.embed(self.delim_code_end_3.builder);
4719        let node_id = builder.non_terminal(NonTerminalKind::DelimCodeEnd3, vec![delim_code_end_3]);
4720        DelimCodeEnd3Node { node_id, builder }
4721    }
4722}
4723#[derive(bon::Builder)]
4724pub struct DelimCodeStart1Constructor {
4725    delim_code_start_1: DelimCodeStart1Token,
4726}
4727impl DelimCodeStart1Constructor {
4728    pub fn build(self) -> DelimCodeStart1Node {
4729        let mut builder = CstBuilder::new();
4730        let delim_code_start_1 = builder.embed(self.delim_code_start_1.builder);
4731        let node_id =
4732            builder.non_terminal(NonTerminalKind::DelimCodeStart1, vec![delim_code_start_1]);
4733        DelimCodeStart1Node { node_id, builder }
4734    }
4735}
4736#[derive(bon::Builder)]
4737pub struct DelimCodeStart2Constructor {
4738    delim_code_start_2: DelimCodeStart2Token,
4739}
4740impl DelimCodeStart2Constructor {
4741    pub fn build(self) -> DelimCodeStart2Node {
4742        let mut builder = CstBuilder::new();
4743        let delim_code_start_2 = builder.embed(self.delim_code_start_2.builder);
4744        let node_id =
4745            builder.non_terminal(NonTerminalKind::DelimCodeStart2, vec![delim_code_start_2]);
4746        DelimCodeStart2Node { node_id, builder }
4747    }
4748}
4749#[derive(bon::Builder)]
4750pub struct DelimCodeStart3Constructor {
4751    delim_code_start_3: DelimCodeStart3Token,
4752}
4753impl DelimCodeStart3Constructor {
4754    pub fn build(self) -> DelimCodeStart3Node {
4755        let mut builder = CstBuilder::new();
4756        let delim_code_start_3 = builder.embed(self.delim_code_start_3.builder);
4757        let node_id =
4758            builder.non_terminal(NonTerminalKind::DelimCodeStart3, vec![delim_code_start_3]);
4759        DelimCodeStart3Node { node_id, builder }
4760    }
4761}
4762#[derive(bon::Builder)]
4763pub struct DotConstructor {
4764    dot: DotToken,
4765}
4766impl DotConstructor {
4767    pub fn build(self) -> DotNode {
4768        let mut builder = CstBuilder::new();
4769        let dot = builder.embed(self.dot.builder);
4770        let node_id = builder.non_terminal(NonTerminalKind::Dot, vec![dot]);
4771        DotNode { node_id, builder }
4772    }
4773}
4774#[derive(bon::Builder)]
4775pub struct DotKeyConstructor {
4776    dot: DotNode,
4777    key: KeyNode,
4778}
4779impl DotKeyConstructor {
4780    pub fn build(self) -> DotKeyNode {
4781        let mut builder = CstBuilder::new();
4782        let dot = builder.embed(self.dot.builder);
4783        let key = builder.embed(self.key.builder);
4784        let node_id = builder.non_terminal(NonTerminalKind::DotKey, vec![dot, key]);
4785        DotKeyNode { node_id, builder }
4786    }
4787}
4788#[derive(bon::Builder)]
4789pub struct EndConstructor {
4790    r_brace: RBraceToken,
4791}
4792impl EndConstructor {
4793    pub fn build(self) -> EndNode {
4794        let mut builder = CstBuilder::new();
4795        let r_brace = builder.embed(self.r_brace.builder);
4796        let node_id = builder.non_terminal(NonTerminalKind::End, vec![r_brace]);
4797        EndNode { node_id, builder }
4798    }
4799}
4800#[derive(bon::Builder)]
4801pub struct EureConstructor {
4802    eure_opt: EureOptNode,
4803    eure_bindings: EureBindingsNode,
4804    eure_sections: EureSectionsNode,
4805}
4806impl EureConstructor {
4807    pub fn build(self) -> EureNode {
4808        let mut builder = CstBuilder::new();
4809        let eure_opt = builder.embed(self.eure_opt.builder);
4810        let eure_bindings = builder.embed(self.eure_bindings.builder);
4811        let eure_sections = builder.embed(self.eure_sections.builder);
4812        let node_id = builder.non_terminal(
4813            NonTerminalKind::Eure,
4814            vec![eure_opt, eure_bindings, eure_sections],
4815        );
4816        EureNode { node_id, builder }
4817    }
4818}
4819#[derive(bon::Builder)]
4820pub struct EureBindingsConstructor {
4821    binding: BindingNode,
4822    eure_bindings: EureBindingsNode,
4823}
4824impl EureBindingsConstructor {
4825    /// Create an empty node (base case for recursion)
4826    pub fn empty() -> EureBindingsNode {
4827        let mut builder = CstBuilder::new();
4828        let node_id = builder.non_terminal(NonTerminalKind::EureList, Vec::<BuilderNodeId>::new());
4829        EureBindingsNode { node_id, builder }
4830    }
4831    /// Create a node with children (recursive case)
4832    pub fn build(self) -> EureBindingsNode {
4833        let mut builder = CstBuilder::new();
4834        let binding = builder.embed(self.binding.builder);
4835        let eure_bindings = builder.embed(self.eure_bindings.builder);
4836        let node_id = builder.non_terminal(NonTerminalKind::EureList, vec![binding, eure_bindings]);
4837        EureBindingsNode { node_id, builder }
4838    }
4839}
4840#[derive(bon::Builder)]
4841pub struct EureSectionsConstructor {
4842    section: SectionNode,
4843    eure_sections: EureSectionsNode,
4844}
4845impl EureSectionsConstructor {
4846    /// Create an empty node (base case for recursion)
4847    pub fn empty() -> EureSectionsNode {
4848        let mut builder = CstBuilder::new();
4849        let node_id = builder.non_terminal(NonTerminalKind::EureList0, Vec::<BuilderNodeId>::new());
4850        EureSectionsNode { node_id, builder }
4851    }
4852    /// Create a node with children (recursive case)
4853    pub fn build(self) -> EureSectionsNode {
4854        let mut builder = CstBuilder::new();
4855        let section = builder.embed(self.section.builder);
4856        let eure_sections = builder.embed(self.eure_sections.builder);
4857        let node_id =
4858            builder.non_terminal(NonTerminalKind::EureList0, vec![section, eure_sections]);
4859        EureSectionsNode { node_id, builder }
4860    }
4861}
4862#[derive(bon::Builder)]
4863pub struct EureOptConstructor {
4864    top_level_binding: Option<TopLevelBindingNode>,
4865}
4866impl EureOptConstructor {
4867    pub fn build(self) -> EureOptNode {
4868        let mut builder = CstBuilder::new();
4869        let children = if let Some(child) = self.top_level_binding {
4870            vec![builder.embed(child.builder)]
4871        } else {
4872            Vec::<BuilderNodeId>::new()
4873        };
4874        let node_id = builder.non_terminal(NonTerminalKind::EureOpt, children);
4875        EureOptNode { node_id, builder }
4876    }
4877}
4878#[derive(bon::Builder)]
4879pub struct ExtConstructor {
4880    dollar: DollarToken,
4881}
4882impl ExtConstructor {
4883    pub fn build(self) -> ExtNode {
4884        let mut builder = CstBuilder::new();
4885        let dollar = builder.embed(self.dollar.builder);
4886        let node_id = builder.non_terminal(NonTerminalKind::Ext, vec![dollar]);
4887        ExtNode { node_id, builder }
4888    }
4889}
4890#[derive(bon::Builder)]
4891pub struct ExtensionNameSpaceConstructor {
4892    ext: ExtNode,
4893    key_ident: KeyIdentNode,
4894}
4895impl ExtensionNameSpaceConstructor {
4896    pub fn build(self) -> ExtensionNameSpaceNode {
4897        let mut builder = CstBuilder::new();
4898        let ext = builder.embed(self.ext.builder);
4899        let key_ident = builder.embed(self.key_ident.builder);
4900        let node_id =
4901            builder.non_terminal(NonTerminalKind::ExtensionNameSpace, vec![ext, key_ident]);
4902        ExtensionNameSpaceNode { node_id, builder }
4903    }
4904}
4905#[derive(bon::Builder)]
4906pub struct FalseConstructor {
4907    r#false: FalseToken,
4908}
4909impl FalseConstructor {
4910    pub fn build(self) -> FalseNode {
4911        let mut builder = CstBuilder::new();
4912        let r#false = builder.embed(self.r#false.builder);
4913        let node_id = builder.non_terminal(NonTerminalKind::False, vec![r#false]);
4914        FalseNode { node_id, builder }
4915    }
4916}
4917pub enum FirstKeyConstructor {
4918    Key(KeyNode),
4919    ArrayMarker(ArrayMarkerNode),
4920}
4921impl FirstKeyConstructor {
4922    pub fn build(self) -> FirstKeyNode {
4923        let mut builder = CstBuilder::new();
4924        let child_id = match self {
4925            Self::Key(node) => builder.embed(node.builder),
4926            Self::ArrayMarker(node) => builder.embed(node.builder),
4927        };
4928        let node_id = builder.non_terminal(NonTerminalKind::FirstKey, vec![child_id]);
4929        FirstKeyNode { node_id, builder }
4930    }
4931}
4932#[derive(bon::Builder)]
4933pub struct FlatBodyConstructor {
4934    section_head: SectionHeadNode,
4935    flat_body_list: FlatBodyListNode,
4936}
4937impl FlatBodyConstructor {
4938    pub fn build(self) -> FlatBodyNode {
4939        let mut builder = CstBuilder::new();
4940        let section_head = builder.embed(self.section_head.builder);
4941        let flat_body_list = builder.embed(self.flat_body_list.builder);
4942        let node_id = builder.non_terminal(
4943            NonTerminalKind::FlatBody,
4944            vec![section_head, flat_body_list],
4945        );
4946        FlatBodyNode { node_id, builder }
4947    }
4948}
4949#[derive(bon::Builder)]
4950pub struct FlatBodyListConstructor {
4951    binding: BindingNode,
4952    flat_body_list: FlatBodyListNode,
4953}
4954impl FlatBodyListConstructor {
4955    /// Create an empty node (base case for recursion)
4956    pub fn empty() -> FlatBodyListNode {
4957        let mut builder = CstBuilder::new();
4958        let node_id =
4959            builder.non_terminal(NonTerminalKind::FlatBodyList, Vec::<BuilderNodeId>::new());
4960        FlatBodyListNode { node_id, builder }
4961    }
4962    /// Create a node with children (recursive case)
4963    pub fn build(self) -> FlatBodyListNode {
4964        let mut builder = CstBuilder::new();
4965        let binding = builder.embed(self.binding.builder);
4966        let flat_body_list = builder.embed(self.flat_body_list.builder);
4967        let node_id =
4968            builder.non_terminal(NonTerminalKind::FlatBodyList, vec![binding, flat_body_list]);
4969        FlatBodyListNode { node_id, builder }
4970    }
4971}
4972pub enum FlatRootBindingConstructor {
4973    ValueBinding(ValueBindingNode),
4974    TextBinding(TextBindingNode),
4975}
4976impl FlatRootBindingConstructor {
4977    pub fn build(self) -> FlatRootBindingNode {
4978        let mut builder = CstBuilder::new();
4979        let child_id = match self {
4980            Self::ValueBinding(node) => builder.embed(node.builder),
4981            Self::TextBinding(node) => builder.embed(node.builder),
4982        };
4983        let node_id = builder.non_terminal(NonTerminalKind::FlatRootBinding, vec![child_id]);
4984        FlatRootBindingNode { node_id, builder }
4985    }
4986}
4987#[derive(bon::Builder)]
4988pub struct FloatConstructor {
4989    float: FloatToken,
4990}
4991impl FloatConstructor {
4992    pub fn build(self) -> FloatNode {
4993        let mut builder = CstBuilder::new();
4994        let float = builder.embed(self.float.builder);
4995        let node_id = builder.non_terminal(NonTerminalKind::Float, vec![float]);
4996        FloatNode { node_id, builder }
4997    }
4998}
4999#[derive(bon::Builder)]
5000pub struct GrammarNewlineConstructor {
5001    grammar_newline: GrammarNewlineToken,
5002}
5003impl GrammarNewlineConstructor {
5004    pub fn build(self) -> GrammarNewlineNode {
5005        let mut builder = CstBuilder::new();
5006        let grammar_newline = builder.embed(self.grammar_newline.builder);
5007        let node_id = builder.non_terminal(NonTerminalKind::GrammarNewline, vec![grammar_newline]);
5008        GrammarNewlineNode { node_id, builder }
5009    }
5010}
5011#[derive(bon::Builder)]
5012pub struct HoleConstructor {
5013    hole: HoleToken,
5014}
5015impl HoleConstructor {
5016    pub fn build(self) -> HoleNode {
5017        let mut builder = CstBuilder::new();
5018        let hole = builder.embed(self.hole.builder);
5019        let node_id = builder.non_terminal(NonTerminalKind::Hole, vec![hole]);
5020        HoleNode { node_id, builder }
5021    }
5022}
5023#[derive(bon::Builder)]
5024pub struct IdentConstructor {
5025    ident: IdentToken,
5026}
5027impl IdentConstructor {
5028    pub fn build(self) -> IdentNode {
5029        let mut builder = CstBuilder::new();
5030        let ident = builder.embed(self.ident.builder);
5031        let node_id = builder.non_terminal(NonTerminalKind::Ident, vec![ident]);
5032        IdentNode { node_id, builder }
5033    }
5034}
5035#[derive(bon::Builder)]
5036pub struct InfConstructor {
5037    inf: InfToken,
5038}
5039impl InfConstructor {
5040    pub fn build(self) -> InfNode {
5041        let mut builder = CstBuilder::new();
5042        let inf = builder.embed(self.inf.builder);
5043        let node_id = builder.non_terminal(NonTerminalKind::Inf, vec![inf]);
5044        InfNode { node_id, builder }
5045    }
5046}
5047pub enum InlineCodeConstructor {
5048    DelimCode(DelimCodeNode),
5049    InlineCode1(InlineCode1Node),
5050}
5051impl InlineCodeConstructor {
5052    pub fn build(self) -> InlineCodeNode {
5053        let mut builder = CstBuilder::new();
5054        let child_id = match self {
5055            Self::DelimCode(node) => builder.embed(node.builder),
5056            Self::InlineCode1(node) => builder.embed(node.builder),
5057        };
5058        let node_id = builder.non_terminal(NonTerminalKind::InlineCode, vec![child_id]);
5059        InlineCodeNode { node_id, builder }
5060    }
5061}
5062#[derive(bon::Builder)]
5063pub struct InlineCode1Constructor {
5064    inline_code_1: InlineCode1Token,
5065}
5066impl InlineCode1Constructor {
5067    pub fn build(self) -> InlineCode1Node {
5068        let mut builder = CstBuilder::new();
5069        let inline_code_1 = builder.embed(self.inline_code_1.builder);
5070        let node_id = builder.non_terminal(NonTerminalKind::InlineCode1, vec![inline_code_1]);
5071        InlineCode1Node { node_id, builder }
5072    }
5073}
5074#[derive(bon::Builder)]
5075pub struct IntegerConstructor {
5076    integer: IntegerToken,
5077}
5078impl IntegerConstructor {
5079    pub fn build(self) -> IntegerNode {
5080        let mut builder = CstBuilder::new();
5081        let integer = builder.embed(self.integer.builder);
5082        let node_id = builder.non_terminal(NonTerminalKind::Integer, vec![integer]);
5083        IntegerNode { node_id, builder }
5084    }
5085}
5086pub enum KeyConstructor {
5087    KeyIdent(KeyIdentNode),
5088    ExtensionNameSpace(ExtensionNameSpaceNode),
5089    String(StringNode),
5090    Integer(IntegerNode),
5091    Float(FloatNode),
5092    KeyTuple(KeyTupleNode),
5093    TupleIndex(TupleIndexNode),
5094}
5095impl KeyConstructor {
5096    pub fn build(self) -> KeyNode {
5097        let mut builder = CstBuilder::new();
5098        let child_id = match self {
5099            Self::KeyIdent(node) => builder.embed(node.builder),
5100            Self::ExtensionNameSpace(node) => builder.embed(node.builder),
5101            Self::String(node) => builder.embed(node.builder),
5102            Self::Integer(node) => builder.embed(node.builder),
5103            Self::Float(node) => builder.embed(node.builder),
5104            Self::KeyTuple(node) => builder.embed(node.builder),
5105            Self::TupleIndex(node) => builder.embed(node.builder),
5106        };
5107        let node_id = builder.non_terminal(NonTerminalKind::Key, vec![child_id]);
5108        KeyNode { node_id, builder }
5109    }
5110}
5111pub enum KeyIdentConstructor {
5112    Ident(IdentNode),
5113    True(TrueNode),
5114    False(FalseNode),
5115    Null(NullNode),
5116}
5117impl KeyIdentConstructor {
5118    pub fn build(self) -> KeyIdentNode {
5119        let mut builder = CstBuilder::new();
5120        let child_id = match self {
5121            Self::Ident(node) => builder.embed(node.builder),
5122            Self::True(node) => builder.embed(node.builder),
5123            Self::False(node) => builder.embed(node.builder),
5124            Self::Null(node) => builder.embed(node.builder),
5125        };
5126        let node_id = builder.non_terminal(NonTerminalKind::KeyIdent, vec![child_id]);
5127        KeyIdentNode { node_id, builder }
5128    }
5129}
5130pub enum KeyTailConstructor {
5131    DotKey(DotKeyNode),
5132    ArrayMarker(ArrayMarkerNode),
5133}
5134impl KeyTailConstructor {
5135    pub fn build(self) -> KeyTailNode {
5136        let mut builder = CstBuilder::new();
5137        let child_id = match self {
5138            Self::DotKey(node) => builder.embed(node.builder),
5139            Self::ArrayMarker(node) => builder.embed(node.builder),
5140        };
5141        let node_id = builder.non_terminal(NonTerminalKind::KeyTail, vec![child_id]);
5142        KeyTailNode { node_id, builder }
5143    }
5144}
5145#[derive(bon::Builder)]
5146pub struct KeyTupleConstructor {
5147    l_paren: LParenNode,
5148    key_tuple_opt: KeyTupleOptNode,
5149    r_paren: RParenNode,
5150}
5151impl KeyTupleConstructor {
5152    pub fn build(self) -> KeyTupleNode {
5153        let mut builder = CstBuilder::new();
5154        let l_paren = builder.embed(self.l_paren.builder);
5155        let key_tuple_opt = builder.embed(self.key_tuple_opt.builder);
5156        let r_paren = builder.embed(self.r_paren.builder);
5157        let node_id = builder.non_terminal(
5158            NonTerminalKind::KeyTuple,
5159            vec![l_paren, key_tuple_opt, r_paren],
5160        );
5161        KeyTupleNode { node_id, builder }
5162    }
5163}
5164#[derive(bon::Builder)]
5165pub struct KeyTupleElementsConstructor {
5166    key_value: KeyValueNode,
5167    key_tuple_elements_opt: KeyTupleElementsOptNode,
5168}
5169impl KeyTupleElementsConstructor {
5170    pub fn build(self) -> KeyTupleElementsNode {
5171        let mut builder = CstBuilder::new();
5172        let key_value = builder.embed(self.key_value.builder);
5173        let key_tuple_elements_opt = builder.embed(self.key_tuple_elements_opt.builder);
5174        let node_id = builder.non_terminal(
5175            NonTerminalKind::KeyTupleElements,
5176            vec![key_value, key_tuple_elements_opt],
5177        );
5178        KeyTupleElementsNode { node_id, builder }
5179    }
5180}
5181#[derive(bon::Builder)]
5182pub struct KeyTupleElementsOptConstructor {
5183    key_tuple_elements_tail: Option<KeyTupleElementsTailNode>,
5184}
5185impl KeyTupleElementsOptConstructor {
5186    pub fn build(self) -> KeyTupleElementsOptNode {
5187        let mut builder = CstBuilder::new();
5188        let children = if let Some(child) = self.key_tuple_elements_tail {
5189            vec![builder.embed(child.builder)]
5190        } else {
5191            Vec::<BuilderNodeId>::new()
5192        };
5193        let node_id = builder.non_terminal(NonTerminalKind::KeyTupleElementsOpt, children);
5194        KeyTupleElementsOptNode { node_id, builder }
5195    }
5196}
5197#[derive(bon::Builder)]
5198pub struct KeyTupleElementsTailConstructor {
5199    comma: CommaNode,
5200    key_tuple_elements_tail_opt: KeyTupleElementsTailOptNode,
5201}
5202impl KeyTupleElementsTailConstructor {
5203    pub fn build(self) -> KeyTupleElementsTailNode {
5204        let mut builder = CstBuilder::new();
5205        let comma = builder.embed(self.comma.builder);
5206        let key_tuple_elements_tail_opt = builder.embed(self.key_tuple_elements_tail_opt.builder);
5207        let node_id = builder.non_terminal(
5208            NonTerminalKind::KeyTupleElementsTail,
5209            vec![comma, key_tuple_elements_tail_opt],
5210        );
5211        KeyTupleElementsTailNode { node_id, builder }
5212    }
5213}
5214#[derive(bon::Builder)]
5215pub struct KeyTupleElementsTailOptConstructor {
5216    key_tuple_elements: Option<KeyTupleElementsNode>,
5217}
5218impl KeyTupleElementsTailOptConstructor {
5219    pub fn build(self) -> KeyTupleElementsTailOptNode {
5220        let mut builder = CstBuilder::new();
5221        let children = if let Some(child) = self.key_tuple_elements {
5222            vec![builder.embed(child.builder)]
5223        } else {
5224            Vec::<BuilderNodeId>::new()
5225        };
5226        let node_id = builder.non_terminal(NonTerminalKind::KeyTupleElementsTailOpt, children);
5227        KeyTupleElementsTailOptNode { node_id, builder }
5228    }
5229}
5230#[derive(bon::Builder)]
5231pub struct KeyTupleOptConstructor {
5232    key_tuple_elements: Option<KeyTupleElementsNode>,
5233}
5234impl KeyTupleOptConstructor {
5235    pub fn build(self) -> KeyTupleOptNode {
5236        let mut builder = CstBuilder::new();
5237        let children = if let Some(child) = self.key_tuple_elements {
5238            vec![builder.embed(child.builder)]
5239        } else {
5240            Vec::<BuilderNodeId>::new()
5241        };
5242        let node_id = builder.non_terminal(NonTerminalKind::KeyTupleOpt, children);
5243        KeyTupleOptNode { node_id, builder }
5244    }
5245}
5246pub enum KeyValueConstructor {
5247    Integer(IntegerNode),
5248    Boolean(BooleanNode),
5249    Str(StrNode),
5250    KeyTuple(KeyTupleNode),
5251}
5252impl KeyValueConstructor {
5253    pub fn build(self) -> KeyValueNode {
5254        let mut builder = CstBuilder::new();
5255        let child_id = match self {
5256            Self::Integer(node) => builder.embed(node.builder),
5257            Self::Boolean(node) => builder.embed(node.builder),
5258            Self::Str(node) => builder.embed(node.builder),
5259            Self::KeyTuple(node) => builder.embed(node.builder),
5260        };
5261        let node_id = builder.non_terminal(NonTerminalKind::KeyValue, vec![child_id]);
5262        KeyValueNode { node_id, builder }
5263    }
5264}
5265#[derive(bon::Builder)]
5266pub struct KeysConstructor {
5267    first_key: FirstKeyNode,
5268    keys_list: KeysListNode,
5269}
5270impl KeysConstructor {
5271    pub fn build(self) -> KeysNode {
5272        let mut builder = CstBuilder::new();
5273        let first_key = builder.embed(self.first_key.builder);
5274        let keys_list = builder.embed(self.keys_list.builder);
5275        let node_id = builder.non_terminal(NonTerminalKind::Keys, vec![first_key, keys_list]);
5276        KeysNode { node_id, builder }
5277    }
5278}
5279#[derive(bon::Builder)]
5280pub struct KeysListConstructor {
5281    key_tail: KeyTailNode,
5282    keys_list: KeysListNode,
5283}
5284impl KeysListConstructor {
5285    /// Create an empty node (base case for recursion)
5286    pub fn empty() -> KeysListNode {
5287        let mut builder = CstBuilder::new();
5288        let node_id = builder.non_terminal(NonTerminalKind::KeysList, Vec::<BuilderNodeId>::new());
5289        KeysListNode { node_id, builder }
5290    }
5291    /// Create a node with children (recursive case)
5292    pub fn build(self) -> KeysListNode {
5293        let mut builder = CstBuilder::new();
5294        let key_tail = builder.embed(self.key_tail.builder);
5295        let keys_list = builder.embed(self.keys_list.builder);
5296        let node_id = builder.non_terminal(NonTerminalKind::KeysList, vec![key_tail, keys_list]);
5297        KeysListNode { node_id, builder }
5298    }
5299}
5300#[derive(bon::Builder)]
5301pub struct LParenConstructor {
5302    l_paren: LParenToken,
5303}
5304impl LParenConstructor {
5305    pub fn build(self) -> LParenNode {
5306        let mut builder = CstBuilder::new();
5307        let l_paren = builder.embed(self.l_paren.builder);
5308        let node_id = builder.non_terminal(NonTerminalKind::LParen, vec![l_paren]);
5309        LParenNode { node_id, builder }
5310    }
5311}
5312#[derive(bon::Builder)]
5313pub struct LitStrConstructor {
5314    lit_str: LitStrToken,
5315}
5316impl LitStrConstructor {
5317    pub fn build(self) -> LitStrNode {
5318        let mut builder = CstBuilder::new();
5319        let lit_str = builder.embed(self.lit_str.builder);
5320        let node_id = builder.non_terminal(NonTerminalKind::LitStr, vec![lit_str]);
5321        LitStrNode { node_id, builder }
5322    }
5323}
5324#[derive(bon::Builder)]
5325pub struct LitStr1Constructor {
5326    lit_str_1_start: LitStr1StartNode,
5327    lit_str_1_list: LitStr1ListNode,
5328    lit_str_1_end: LitStr1EndNode,
5329}
5330impl LitStr1Constructor {
5331    pub fn build(self) -> LitStr1Node {
5332        let mut builder = CstBuilder::new();
5333        let lit_str_1_start = builder.embed(self.lit_str_1_start.builder);
5334        let lit_str_1_list = builder.embed(self.lit_str_1_list.builder);
5335        let lit_str_1_end = builder.embed(self.lit_str_1_end.builder);
5336        let node_id = builder.non_terminal(
5337            NonTerminalKind::LitStr1,
5338            vec![lit_str_1_start, lit_str_1_list, lit_str_1_end],
5339        );
5340        LitStr1Node { node_id, builder }
5341    }
5342}
5343#[derive(bon::Builder)]
5344pub struct LitStr1EndConstructor {
5345    lit_str_1_end: LitStr1EndToken,
5346}
5347impl LitStr1EndConstructor {
5348    pub fn build(self) -> LitStr1EndNode {
5349        let mut builder = CstBuilder::new();
5350        let lit_str_1_end = builder.embed(self.lit_str_1_end.builder);
5351        let node_id = builder.non_terminal(NonTerminalKind::LitStr1End, vec![lit_str_1_end]);
5352        LitStr1EndNode { node_id, builder }
5353    }
5354}
5355#[derive(bon::Builder)]
5356pub struct LitStr1ListConstructor {
5357    lit_str_1_list_group: LitStr1ListGroupNode,
5358    lit_str_1_list: LitStr1ListNode,
5359}
5360impl LitStr1ListConstructor {
5361    /// Create an empty node (base case for recursion)
5362    pub fn empty() -> LitStr1ListNode {
5363        let mut builder = CstBuilder::new();
5364        let node_id =
5365            builder.non_terminal(NonTerminalKind::LitStr1List, Vec::<BuilderNodeId>::new());
5366        LitStr1ListNode { node_id, builder }
5367    }
5368    /// Create a node with children (recursive case)
5369    pub fn build(self) -> LitStr1ListNode {
5370        let mut builder = CstBuilder::new();
5371        let lit_str_1_list_group = builder.embed(self.lit_str_1_list_group.builder);
5372        let lit_str_1_list = builder.embed(self.lit_str_1_list.builder);
5373        let node_id = builder.non_terminal(
5374            NonTerminalKind::LitStr1List,
5375            vec![lit_str_1_list_group, lit_str_1_list],
5376        );
5377        LitStr1ListNode { node_id, builder }
5378    }
5379}
5380pub enum LitStr1ListGroupConstructor {
5381    NoSQuote(NoSQuoteNode),
5382    SQuote(SQuoteNode),
5383}
5384impl LitStr1ListGroupConstructor {
5385    pub fn build(self) -> LitStr1ListGroupNode {
5386        let mut builder = CstBuilder::new();
5387        let child_id = match self {
5388            Self::NoSQuote(node) => builder.embed(node.builder),
5389            Self::SQuote(node) => builder.embed(node.builder),
5390        };
5391        let node_id = builder.non_terminal(NonTerminalKind::LitStr1ListGroup, vec![child_id]);
5392        LitStr1ListGroupNode { node_id, builder }
5393    }
5394}
5395#[derive(bon::Builder)]
5396pub struct LitStr1StartConstructor {
5397    lit_str_1_start: LitStr1StartToken,
5398}
5399impl LitStr1StartConstructor {
5400    pub fn build(self) -> LitStr1StartNode {
5401        let mut builder = CstBuilder::new();
5402        let lit_str_1_start = builder.embed(self.lit_str_1_start.builder);
5403        let node_id = builder.non_terminal(NonTerminalKind::LitStr1Start, vec![lit_str_1_start]);
5404        LitStr1StartNode { node_id, builder }
5405    }
5406}
5407#[derive(bon::Builder)]
5408pub struct LitStr2Constructor {
5409    lit_str_2_start: LitStr2StartNode,
5410    lit_str_2_list: LitStr2ListNode,
5411    lit_str_2_end: LitStr2EndNode,
5412}
5413impl LitStr2Constructor {
5414    pub fn build(self) -> LitStr2Node {
5415        let mut builder = CstBuilder::new();
5416        let lit_str_2_start = builder.embed(self.lit_str_2_start.builder);
5417        let lit_str_2_list = builder.embed(self.lit_str_2_list.builder);
5418        let lit_str_2_end = builder.embed(self.lit_str_2_end.builder);
5419        let node_id = builder.non_terminal(
5420            NonTerminalKind::LitStr2,
5421            vec![lit_str_2_start, lit_str_2_list, lit_str_2_end],
5422        );
5423        LitStr2Node { node_id, builder }
5424    }
5425}
5426#[derive(bon::Builder)]
5427pub struct LitStr2EndConstructor {
5428    lit_str_2_end: LitStr2EndToken,
5429}
5430impl LitStr2EndConstructor {
5431    pub fn build(self) -> LitStr2EndNode {
5432        let mut builder = CstBuilder::new();
5433        let lit_str_2_end = builder.embed(self.lit_str_2_end.builder);
5434        let node_id = builder.non_terminal(NonTerminalKind::LitStr2End, vec![lit_str_2_end]);
5435        LitStr2EndNode { node_id, builder }
5436    }
5437}
5438#[derive(bon::Builder)]
5439pub struct LitStr2ListConstructor {
5440    lit_str_2_list_group: LitStr2ListGroupNode,
5441    lit_str_2_list: LitStr2ListNode,
5442}
5443impl LitStr2ListConstructor {
5444    /// Create an empty node (base case for recursion)
5445    pub fn empty() -> LitStr2ListNode {
5446        let mut builder = CstBuilder::new();
5447        let node_id =
5448            builder.non_terminal(NonTerminalKind::LitStr2List, Vec::<BuilderNodeId>::new());
5449        LitStr2ListNode { node_id, builder }
5450    }
5451    /// Create a node with children (recursive case)
5452    pub fn build(self) -> LitStr2ListNode {
5453        let mut builder = CstBuilder::new();
5454        let lit_str_2_list_group = builder.embed(self.lit_str_2_list_group.builder);
5455        let lit_str_2_list = builder.embed(self.lit_str_2_list.builder);
5456        let node_id = builder.non_terminal(
5457            NonTerminalKind::LitStr2List,
5458            vec![lit_str_2_list_group, lit_str_2_list],
5459        );
5460        LitStr2ListNode { node_id, builder }
5461    }
5462}
5463pub enum LitStr2ListGroupConstructor {
5464    NoSQuote(NoSQuoteNode),
5465    SQuote(SQuoteNode),
5466}
5467impl LitStr2ListGroupConstructor {
5468    pub fn build(self) -> LitStr2ListGroupNode {
5469        let mut builder = CstBuilder::new();
5470        let child_id = match self {
5471            Self::NoSQuote(node) => builder.embed(node.builder),
5472            Self::SQuote(node) => builder.embed(node.builder),
5473        };
5474        let node_id = builder.non_terminal(NonTerminalKind::LitStr2ListGroup, vec![child_id]);
5475        LitStr2ListGroupNode { node_id, builder }
5476    }
5477}
5478#[derive(bon::Builder)]
5479pub struct LitStr2StartConstructor {
5480    lit_str_2_start: LitStr2StartToken,
5481}
5482impl LitStr2StartConstructor {
5483    pub fn build(self) -> LitStr2StartNode {
5484        let mut builder = CstBuilder::new();
5485        let lit_str_2_start = builder.embed(self.lit_str_2_start.builder);
5486        let node_id = builder.non_terminal(NonTerminalKind::LitStr2Start, vec![lit_str_2_start]);
5487        LitStr2StartNode { node_id, builder }
5488    }
5489}
5490#[derive(bon::Builder)]
5491pub struct LitStr3Constructor {
5492    lit_str_3_start: LitStr3StartNode,
5493    lit_str_3_list: LitStr3ListNode,
5494    lit_str_3_end: LitStr3EndNode,
5495}
5496impl LitStr3Constructor {
5497    pub fn build(self) -> LitStr3Node {
5498        let mut builder = CstBuilder::new();
5499        let lit_str_3_start = builder.embed(self.lit_str_3_start.builder);
5500        let lit_str_3_list = builder.embed(self.lit_str_3_list.builder);
5501        let lit_str_3_end = builder.embed(self.lit_str_3_end.builder);
5502        let node_id = builder.non_terminal(
5503            NonTerminalKind::LitStr3,
5504            vec![lit_str_3_start, lit_str_3_list, lit_str_3_end],
5505        );
5506        LitStr3Node { node_id, builder }
5507    }
5508}
5509#[derive(bon::Builder)]
5510pub struct LitStr3EndConstructor {
5511    lit_str_3_end: LitStr3EndToken,
5512}
5513impl LitStr3EndConstructor {
5514    pub fn build(self) -> LitStr3EndNode {
5515        let mut builder = CstBuilder::new();
5516        let lit_str_3_end = builder.embed(self.lit_str_3_end.builder);
5517        let node_id = builder.non_terminal(NonTerminalKind::LitStr3End, vec![lit_str_3_end]);
5518        LitStr3EndNode { node_id, builder }
5519    }
5520}
5521#[derive(bon::Builder)]
5522pub struct LitStr3ListConstructor {
5523    lit_str_3_list_group: LitStr3ListGroupNode,
5524    lit_str_3_list: LitStr3ListNode,
5525}
5526impl LitStr3ListConstructor {
5527    /// Create an empty node (base case for recursion)
5528    pub fn empty() -> LitStr3ListNode {
5529        let mut builder = CstBuilder::new();
5530        let node_id =
5531            builder.non_terminal(NonTerminalKind::LitStr3List, Vec::<BuilderNodeId>::new());
5532        LitStr3ListNode { node_id, builder }
5533    }
5534    /// Create a node with children (recursive case)
5535    pub fn build(self) -> LitStr3ListNode {
5536        let mut builder = CstBuilder::new();
5537        let lit_str_3_list_group = builder.embed(self.lit_str_3_list_group.builder);
5538        let lit_str_3_list = builder.embed(self.lit_str_3_list.builder);
5539        let node_id = builder.non_terminal(
5540            NonTerminalKind::LitStr3List,
5541            vec![lit_str_3_list_group, lit_str_3_list],
5542        );
5543        LitStr3ListNode { node_id, builder }
5544    }
5545}
5546pub enum LitStr3ListGroupConstructor {
5547    NoSQuote(NoSQuoteNode),
5548    SQuote(SQuoteNode),
5549}
5550impl LitStr3ListGroupConstructor {
5551    pub fn build(self) -> LitStr3ListGroupNode {
5552        let mut builder = CstBuilder::new();
5553        let child_id = match self {
5554            Self::NoSQuote(node) => builder.embed(node.builder),
5555            Self::SQuote(node) => builder.embed(node.builder),
5556        };
5557        let node_id = builder.non_terminal(NonTerminalKind::LitStr3ListGroup, vec![child_id]);
5558        LitStr3ListGroupNode { node_id, builder }
5559    }
5560}
5561#[derive(bon::Builder)]
5562pub struct LitStr3StartConstructor {
5563    lit_str_3_start: LitStr3StartToken,
5564}
5565impl LitStr3StartConstructor {
5566    pub fn build(self) -> LitStr3StartNode {
5567        let mut builder = CstBuilder::new();
5568        let lit_str_3_start = builder.embed(self.lit_str_3_start.builder);
5569        let node_id = builder.non_terminal(NonTerminalKind::LitStr3Start, vec![lit_str_3_start]);
5570        LitStr3StartNode { node_id, builder }
5571    }
5572}
5573#[derive(bon::Builder)]
5574pub struct MapBindConstructor {
5575    map_bind: MapBindToken,
5576}
5577impl MapBindConstructor {
5578    pub fn build(self) -> MapBindNode {
5579        let mut builder = CstBuilder::new();
5580        let map_bind = builder.embed(self.map_bind.builder);
5581        let node_id = builder.non_terminal(NonTerminalKind::MapBind, vec![map_bind]);
5582        MapBindNode { node_id, builder }
5583    }
5584}
5585#[derive(bon::Builder)]
5586pub struct NaNConstructor {
5587    na_n: NaNToken,
5588}
5589impl NaNConstructor {
5590    pub fn build(self) -> NaNNode {
5591        let mut builder = CstBuilder::new();
5592        let na_n = builder.embed(self.na_n.builder);
5593        let node_id = builder.non_terminal(NonTerminalKind::NaN, vec![na_n]);
5594        NaNNode { node_id, builder }
5595    }
5596}
5597#[derive(bon::Builder)]
5598pub struct NewlineBindConstructor {
5599    newline_bind: NewlineBindToken,
5600}
5601impl NewlineBindConstructor {
5602    pub fn build(self) -> NewlineBindNode {
5603        let mut builder = CstBuilder::new();
5604        let newline_bind = builder.embed(self.newline_bind.builder);
5605        let node_id = builder.non_terminal(NonTerminalKind::NewlineBind, vec![newline_bind]);
5606        NewlineBindNode { node_id, builder }
5607    }
5608}
5609#[derive(bon::Builder)]
5610pub struct NewlineHeadConstructor {
5611    grammar_newline: GrammarNewlineNode,
5612    newline_head_opt: NewlineHeadOptNode,
5613}
5614impl NewlineHeadConstructor {
5615    pub fn build(self) -> NewlineHeadNode {
5616        let mut builder = CstBuilder::new();
5617        let grammar_newline = builder.embed(self.grammar_newline.builder);
5618        let newline_head_opt = builder.embed(self.newline_head_opt.builder);
5619        let node_id = builder.non_terminal(
5620            NonTerminalKind::NewlineHead,
5621            vec![grammar_newline, newline_head_opt],
5622        );
5623        NewlineHeadNode { node_id, builder }
5624    }
5625}
5626#[derive(bon::Builder)]
5627pub struct NewlineHeadOptConstructor {
5628    flat_root_binding: Option<FlatRootBindingNode>,
5629}
5630impl NewlineHeadOptConstructor {
5631    pub fn build(self) -> NewlineHeadOptNode {
5632        let mut builder = CstBuilder::new();
5633        let children = if let Some(child) = self.flat_root_binding {
5634            vec![builder.embed(child.builder)]
5635        } else {
5636            Vec::<BuilderNodeId>::new()
5637        };
5638        let node_id = builder.non_terminal(NonTerminalKind::NewlineHeadOpt, children);
5639        NewlineHeadOptNode { node_id, builder }
5640    }
5641}
5642#[derive(bon::Builder)]
5643pub struct NewlineTextStartConstructor {
5644    newline_text_start: NewlineTextStartToken,
5645}
5646impl NewlineTextStartConstructor {
5647    pub fn build(self) -> NewlineTextStartNode {
5648        let mut builder = CstBuilder::new();
5649        let newline_text_start = builder.embed(self.newline_text_start.builder);
5650        let node_id =
5651            builder.non_terminal(NonTerminalKind::NewlineTextStart, vec![newline_text_start]);
5652        NewlineTextStartNode { node_id, builder }
5653    }
5654}
5655#[derive(bon::Builder)]
5656pub struct NoBacktickConstructor {
5657    no_backtick: NoBacktickToken,
5658}
5659impl NoBacktickConstructor {
5660    pub fn build(self) -> NoBacktickNode {
5661        let mut builder = CstBuilder::new();
5662        let no_backtick = builder.embed(self.no_backtick.builder);
5663        let node_id = builder.non_terminal(NonTerminalKind::NoBacktick, vec![no_backtick]);
5664        NoBacktickNode { node_id, builder }
5665    }
5666}
5667#[derive(bon::Builder)]
5668pub struct NoSQuoteConstructor {
5669    no_s_quote: NoSQuoteToken,
5670}
5671impl NoSQuoteConstructor {
5672    pub fn build(self) -> NoSQuoteNode {
5673        let mut builder = CstBuilder::new();
5674        let no_s_quote = builder.embed(self.no_s_quote.builder);
5675        let node_id = builder.non_terminal(NonTerminalKind::NoSQuote, vec![no_s_quote]);
5676        NoSQuoteNode { node_id, builder }
5677    }
5678}
5679#[derive(bon::Builder)]
5680pub struct NullConstructor {
5681    null: NullToken,
5682}
5683impl NullConstructor {
5684    pub fn build(self) -> NullNode {
5685        let mut builder = CstBuilder::new();
5686        let null = builder.embed(self.null.builder);
5687        let node_id = builder.non_terminal(NonTerminalKind::Null, vec![null]);
5688        NullNode { node_id, builder }
5689    }
5690}
5691pub enum NumberConstructor {
5692    Float(FloatNode),
5693    Integer(IntegerNode),
5694    Inf(InfNode),
5695    NaN(NaNNode),
5696}
5697impl NumberConstructor {
5698    pub fn build(self) -> NumberNode {
5699        let mut builder = CstBuilder::new();
5700        let child_id = match self {
5701            Self::Float(node) => builder.embed(node.builder),
5702            Self::Integer(node) => builder.embed(node.builder),
5703            Self::Inf(node) => builder.embed(node.builder),
5704            Self::NaN(node) => builder.embed(node.builder),
5705        };
5706        let node_id = builder.non_terminal(NonTerminalKind::Number, vec![child_id]);
5707        NumberNode { node_id, builder }
5708    }
5709}
5710#[derive(bon::Builder)]
5711pub struct ObjectConstructor {
5712    begin: BeginNode,
5713    object_opt: ObjectOptNode,
5714    object_list: ObjectListNode,
5715    end: EndNode,
5716}
5717impl ObjectConstructor {
5718    pub fn build(self) -> ObjectNode {
5719        let mut builder = CstBuilder::new();
5720        let begin = builder.embed(self.begin.builder);
5721        let object_opt = builder.embed(self.object_opt.builder);
5722        let object_list = builder.embed(self.object_list.builder);
5723        let end = builder.embed(self.end.builder);
5724        let node_id = builder.non_terminal(
5725            NonTerminalKind::Object,
5726            vec![begin, object_opt, object_list, end],
5727        );
5728        ObjectNode { node_id, builder }
5729    }
5730}
5731#[derive(bon::Builder)]
5732pub struct ObjectListConstructor {
5733    keys: KeysNode,
5734    map_bind: MapBindNode,
5735    value: ValueNode,
5736    object_opt_0: ObjectOpt0Node,
5737    object_list: ObjectListNode,
5738}
5739impl ObjectListConstructor {
5740    /// Create an empty node (base case for recursion)
5741    pub fn empty() -> ObjectListNode {
5742        let mut builder = CstBuilder::new();
5743        let node_id =
5744            builder.non_terminal(NonTerminalKind::ObjectList, Vec::<BuilderNodeId>::new());
5745        ObjectListNode { node_id, builder }
5746    }
5747    /// Create a node with children (recursive case)
5748    pub fn build(self) -> ObjectListNode {
5749        let mut builder = CstBuilder::new();
5750        let keys = builder.embed(self.keys.builder);
5751        let map_bind = builder.embed(self.map_bind.builder);
5752        let value = builder.embed(self.value.builder);
5753        let object_opt_0 = builder.embed(self.object_opt_0.builder);
5754        let object_list = builder.embed(self.object_list.builder);
5755        let node_id = builder.non_terminal(
5756            NonTerminalKind::ObjectList,
5757            vec![keys, map_bind, value, object_opt_0, object_list],
5758        );
5759        ObjectListNode { node_id, builder }
5760    }
5761}
5762#[derive(bon::Builder)]
5763pub struct ObjectOptConstructor {
5764    value_binding: ValueBindingNode,
5765    object_opt_1: ObjectOpt1Node,
5766}
5767impl ObjectOptConstructor {
5768    pub fn build(self) -> ObjectOptNode {
5769        let mut builder = CstBuilder::new();
5770        let value_binding = builder.embed(self.value_binding.builder);
5771        let object_opt_1 = builder.embed(self.object_opt_1.builder);
5772        let node_id = builder.non_terminal(
5773            NonTerminalKind::ObjectOpt,
5774            vec![value_binding, object_opt_1],
5775        );
5776        ObjectOptNode { node_id, builder }
5777    }
5778}
5779#[derive(bon::Builder)]
5780pub struct ObjectOpt0Constructor {
5781    comma: Option<CommaNode>,
5782}
5783impl ObjectOpt0Constructor {
5784    pub fn build(self) -> ObjectOpt0Node {
5785        let mut builder = CstBuilder::new();
5786        let children = if let Some(child) = self.comma {
5787            vec![builder.embed(child.builder)]
5788        } else {
5789            Vec::<BuilderNodeId>::new()
5790        };
5791        let node_id = builder.non_terminal(NonTerminalKind::ObjectOpt0, children);
5792        ObjectOpt0Node { node_id, builder }
5793    }
5794}
5795#[derive(bon::Builder)]
5796pub struct ObjectOpt1Constructor {
5797    comma: Option<CommaNode>,
5798}
5799impl ObjectOpt1Constructor {
5800    pub fn build(self) -> ObjectOpt1Node {
5801        let mut builder = CstBuilder::new();
5802        let children = if let Some(child) = self.comma {
5803            vec![builder.embed(child.builder)]
5804        } else {
5805            Vec::<BuilderNodeId>::new()
5806        };
5807        let node_id = builder.non_terminal(NonTerminalKind::ObjectOpt1, children);
5808        ObjectOpt1Node { node_id, builder }
5809    }
5810}
5811#[derive(bon::Builder)]
5812pub struct RParenConstructor {
5813    r_paren: RParenToken,
5814}
5815impl RParenConstructor {
5816    pub fn build(self) -> RParenNode {
5817        let mut builder = CstBuilder::new();
5818        let r_paren = builder.embed(self.r_paren.builder);
5819        let node_id = builder.non_terminal(NonTerminalKind::RParen, vec![r_paren]);
5820        RParenNode { node_id, builder }
5821    }
5822}
5823pub enum RootBindingConstructor {
5824    RootValueBinding(RootValueBindingNode),
5825    RootTextBinding(RootTextBindingNode),
5826}
5827impl RootBindingConstructor {
5828    pub fn build(self) -> RootBindingNode {
5829        let mut builder = CstBuilder::new();
5830        let child_id = match self {
5831            Self::RootValueBinding(node) => builder.embed(node.builder),
5832            Self::RootTextBinding(node) => builder.embed(node.builder),
5833        };
5834        let node_id = builder.non_terminal(NonTerminalKind::RootBinding, vec![child_id]);
5835        RootBindingNode { node_id, builder }
5836    }
5837}
5838#[derive(bon::Builder)]
5839pub struct RootTextBindingConstructor {
5840    newline_text_start: NewlineTextStartNode,
5841    root_text_binding_opt: RootTextBindingOptNode,
5842    root_text_binding_opt_0: RootTextBindingOpt0Node,
5843    root_text_binding_opt_1: RootTextBindingOpt1Node,
5844}
5845impl RootTextBindingConstructor {
5846    pub fn build(self) -> RootTextBindingNode {
5847        let mut builder = CstBuilder::new();
5848        let newline_text_start = builder.embed(self.newline_text_start.builder);
5849        let root_text_binding_opt = builder.embed(self.root_text_binding_opt.builder);
5850        let root_text_binding_opt_0 = builder.embed(self.root_text_binding_opt_0.builder);
5851        let root_text_binding_opt_1 = builder.embed(self.root_text_binding_opt_1.builder);
5852        let node_id = builder.non_terminal(
5853            NonTerminalKind::RootTextBinding,
5854            vec![
5855                newline_text_start,
5856                root_text_binding_opt,
5857                root_text_binding_opt_0,
5858                root_text_binding_opt_1,
5859            ],
5860        );
5861        RootTextBindingNode { node_id, builder }
5862    }
5863}
5864#[derive(bon::Builder)]
5865pub struct RootTextBindingOptConstructor {
5866    ws: Option<WsNode>,
5867}
5868impl RootTextBindingOptConstructor {
5869    pub fn build(self) -> RootTextBindingOptNode {
5870        let mut builder = CstBuilder::new();
5871        let children = if let Some(child) = self.ws {
5872            vec![builder.embed(child.builder)]
5873        } else {
5874            Vec::<BuilderNodeId>::new()
5875        };
5876        let node_id = builder.non_terminal(NonTerminalKind::RootTextBindingOpt, children);
5877        RootTextBindingOptNode { node_id, builder }
5878    }
5879}
5880#[derive(bon::Builder)]
5881pub struct RootTextBindingOpt0Constructor {
5882    text: Option<TextNode>,
5883}
5884impl RootTextBindingOpt0Constructor {
5885    pub fn build(self) -> RootTextBindingOpt0Node {
5886        let mut builder = CstBuilder::new();
5887        let children = if let Some(child) = self.text {
5888            vec![builder.embed(child.builder)]
5889        } else {
5890            Vec::<BuilderNodeId>::new()
5891        };
5892        let node_id = builder.non_terminal(NonTerminalKind::RootTextBindingOpt0, children);
5893        RootTextBindingOpt0Node { node_id, builder }
5894    }
5895}
5896#[derive(bon::Builder)]
5897pub struct RootTextBindingOpt1Constructor {
5898    grammar_newline: Option<GrammarNewlineNode>,
5899}
5900impl RootTextBindingOpt1Constructor {
5901    pub fn build(self) -> RootTextBindingOpt1Node {
5902        let mut builder = CstBuilder::new();
5903        let children = if let Some(child) = self.grammar_newline {
5904            vec![builder.embed(child.builder)]
5905        } else {
5906            Vec::<BuilderNodeId>::new()
5907        };
5908        let node_id = builder.non_terminal(NonTerminalKind::RootTextBindingOpt1, children);
5909        RootTextBindingOpt1Node { node_id, builder }
5910    }
5911}
5912#[derive(bon::Builder)]
5913pub struct RootValueBindingConstructor {
5914    newline_bind: NewlineBindNode,
5915    value: ValueNode,
5916}
5917impl RootValueBindingConstructor {
5918    pub fn build(self) -> RootValueBindingNode {
5919        let mut builder = CstBuilder::new();
5920        let newline_bind = builder.embed(self.newline_bind.builder);
5921        let value = builder.embed(self.value.builder);
5922        let node_id =
5923            builder.non_terminal(NonTerminalKind::RootValueBinding, vec![newline_bind, value]);
5924        RootValueBindingNode { node_id, builder }
5925    }
5926}
5927#[derive(bon::Builder)]
5928pub struct SQuoteConstructor {
5929    s_quote: SQuoteToken,
5930}
5931impl SQuoteConstructor {
5932    pub fn build(self) -> SQuoteNode {
5933        let mut builder = CstBuilder::new();
5934        let s_quote = builder.embed(self.s_quote.builder);
5935        let node_id = builder.non_terminal(NonTerminalKind::SQuote, vec![s_quote]);
5936        SQuoteNode { node_id, builder }
5937    }
5938}
5939#[derive(bon::Builder)]
5940pub struct SectionConstructor {
5941    at: AtNode,
5942    keys: KeysNode,
5943    section_body: SectionBodyNode,
5944}
5945impl SectionConstructor {
5946    pub fn build(self) -> SectionNode {
5947        let mut builder = CstBuilder::new();
5948        let at = builder.embed(self.at.builder);
5949        let keys = builder.embed(self.keys.builder);
5950        let section_body = builder.embed(self.section_body.builder);
5951        let node_id = builder.non_terminal(NonTerminalKind::Section, vec![at, keys, section_body]);
5952        SectionNode { node_id, builder }
5953    }
5954}
5955#[derive(bon::Builder)]
5956pub struct SectionBindingConstructor {
5957    begin: BeginNode,
5958    eure: EureNode,
5959    end: EndNode,
5960}
5961impl SectionBindingConstructor {
5962    pub fn build(self) -> SectionBindingNode {
5963        let mut builder = CstBuilder::new();
5964        let begin = builder.embed(self.begin.builder);
5965        let eure = builder.embed(self.eure.builder);
5966        let end = builder.embed(self.end.builder);
5967        let node_id = builder.non_terminal(NonTerminalKind::SectionBinding, vec![begin, eure, end]);
5968        SectionBindingNode { node_id, builder }
5969    }
5970}
5971pub enum SectionBodyConstructor {
5972    SectionBodyOpt(SectionBodyOptNode),
5973    BlockBody(BlockBodyNode),
5974}
5975impl SectionBodyConstructor {
5976    pub fn build(self) -> SectionBodyNode {
5977        let mut builder = CstBuilder::new();
5978        let child_id = match self {
5979            Self::SectionBodyOpt(node) => builder.embed(node.builder),
5980            Self::BlockBody(node) => builder.embed(node.builder),
5981        };
5982        let node_id = builder.non_terminal(NonTerminalKind::SectionBody, vec![child_id]);
5983        SectionBodyNode { node_id, builder }
5984    }
5985}
5986#[derive(bon::Builder)]
5987pub struct SectionBodyOptConstructor {
5988    flat_body: Option<FlatBodyNode>,
5989}
5990impl SectionBodyOptConstructor {
5991    pub fn build(self) -> SectionBodyOptNode {
5992        let mut builder = CstBuilder::new();
5993        let children = if let Some(child) = self.flat_body {
5994            vec![builder.embed(child.builder)]
5995        } else {
5996            Vec::<BuilderNodeId>::new()
5997        };
5998        let node_id = builder.non_terminal(NonTerminalKind::SectionBodyOpt, children);
5999        SectionBodyOptNode { node_id, builder }
6000    }
6001}
6002pub enum SectionHeadConstructor {
6003    RootBinding(RootBindingNode),
6004    NewlineHead(NewlineHeadNode),
6005}
6006impl SectionHeadConstructor {
6007    pub fn build(self) -> SectionHeadNode {
6008        let mut builder = CstBuilder::new();
6009        let child_id = match self {
6010            Self::RootBinding(node) => builder.embed(node.builder),
6011            Self::NewlineHead(node) => builder.embed(node.builder),
6012        };
6013        let node_id = builder.non_terminal(NonTerminalKind::SectionHead, vec![child_id]);
6014        SectionHeadNode { node_id, builder }
6015    }
6016}
6017#[derive(bon::Builder)]
6018pub struct StrConstructor {
6019    str: StrToken,
6020}
6021impl StrConstructor {
6022    pub fn build(self) -> StrNode {
6023        let mut builder = CstBuilder::new();
6024        let str = builder.embed(self.str.builder);
6025        let node_id = builder.non_terminal(NonTerminalKind::Str, vec![str]);
6026        StrNode { node_id, builder }
6027    }
6028}
6029pub enum StringConstructor {
6030    Str(StrNode),
6031    LitStr(LitStrNode),
6032    LitStr1(LitStr1Node),
6033    LitStr2(LitStr2Node),
6034    LitStr3(LitStr3Node),
6035}
6036impl StringConstructor {
6037    pub fn build(self) -> StringNode {
6038        let mut builder = CstBuilder::new();
6039        let child_id = match self {
6040            Self::Str(node) => builder.embed(node.builder),
6041            Self::LitStr(node) => builder.embed(node.builder),
6042            Self::LitStr1(node) => builder.embed(node.builder),
6043            Self::LitStr2(node) => builder.embed(node.builder),
6044            Self::LitStr3(node) => builder.embed(node.builder),
6045        };
6046        let node_id = builder.non_terminal(NonTerminalKind::String, vec![child_id]);
6047        StringNode { node_id, builder }
6048    }
6049}
6050#[derive(bon::Builder)]
6051pub struct StringsConstructor {
6052    string: StringNode,
6053    strings_list: StringsListNode,
6054}
6055impl StringsConstructor {
6056    pub fn build(self) -> StringsNode {
6057        let mut builder = CstBuilder::new();
6058        let string = builder.embed(self.string.builder);
6059        let strings_list = builder.embed(self.strings_list.builder);
6060        let node_id = builder.non_terminal(NonTerminalKind::Strings, vec![string, strings_list]);
6061        StringsNode { node_id, builder }
6062    }
6063}
6064#[derive(bon::Builder)]
6065pub struct StringsListConstructor {
6066    r#continue: ContinueNode,
6067    string: StringNode,
6068    strings_list: StringsListNode,
6069}
6070impl StringsListConstructor {
6071    /// Create an empty node (base case for recursion)
6072    pub fn empty() -> StringsListNode {
6073        let mut builder = CstBuilder::new();
6074        let node_id =
6075            builder.non_terminal(NonTerminalKind::StringsList, Vec::<BuilderNodeId>::new());
6076        StringsListNode { node_id, builder }
6077    }
6078    /// Create a node with children (recursive case)
6079    pub fn build(self) -> StringsListNode {
6080        let mut builder = CstBuilder::new();
6081        let r#continue = builder.embed(self.r#continue.builder);
6082        let string = builder.embed(self.string.builder);
6083        let strings_list = builder.embed(self.strings_list.builder);
6084        let node_id = builder.non_terminal(
6085            NonTerminalKind::StringsList,
6086            vec![r#continue, string, strings_list],
6087        );
6088        StringsListNode { node_id, builder }
6089    }
6090}
6091#[derive(bon::Builder)]
6092pub struct TextConstructor {
6093    text: TextToken,
6094}
6095impl TextConstructor {
6096    pub fn build(self) -> TextNode {
6097        let mut builder = CstBuilder::new();
6098        let text = builder.embed(self.text.builder);
6099        let node_id = builder.non_terminal(NonTerminalKind::Text, vec![text]);
6100        TextNode { node_id, builder }
6101    }
6102}
6103#[derive(bon::Builder)]
6104pub struct TextBindingConstructor {
6105    text_start: TextStartNode,
6106    text_binding_opt: TextBindingOptNode,
6107    text_binding_opt_0: TextBindingOpt0Node,
6108    text_binding_opt_1: TextBindingOpt1Node,
6109}
6110impl TextBindingConstructor {
6111    pub fn build(self) -> TextBindingNode {
6112        let mut builder = CstBuilder::new();
6113        let text_start = builder.embed(self.text_start.builder);
6114        let text_binding_opt = builder.embed(self.text_binding_opt.builder);
6115        let text_binding_opt_0 = builder.embed(self.text_binding_opt_0.builder);
6116        let text_binding_opt_1 = builder.embed(self.text_binding_opt_1.builder);
6117        let node_id = builder.non_terminal(
6118            NonTerminalKind::TextBinding,
6119            vec![
6120                text_start,
6121                text_binding_opt,
6122                text_binding_opt_0,
6123                text_binding_opt_1,
6124            ],
6125        );
6126        TextBindingNode { node_id, builder }
6127    }
6128}
6129#[derive(bon::Builder)]
6130pub struct TextBindingOptConstructor {
6131    ws: Option<WsNode>,
6132}
6133impl TextBindingOptConstructor {
6134    pub fn build(self) -> TextBindingOptNode {
6135        let mut builder = CstBuilder::new();
6136        let children = if let Some(child) = self.ws {
6137            vec![builder.embed(child.builder)]
6138        } else {
6139            Vec::<BuilderNodeId>::new()
6140        };
6141        let node_id = builder.non_terminal(NonTerminalKind::TextBindingOpt, children);
6142        TextBindingOptNode { node_id, builder }
6143    }
6144}
6145#[derive(bon::Builder)]
6146pub struct TextBindingOpt0Constructor {
6147    text: Option<TextNode>,
6148}
6149impl TextBindingOpt0Constructor {
6150    pub fn build(self) -> TextBindingOpt0Node {
6151        let mut builder = CstBuilder::new();
6152        let children = if let Some(child) = self.text {
6153            vec![builder.embed(child.builder)]
6154        } else {
6155            Vec::<BuilderNodeId>::new()
6156        };
6157        let node_id = builder.non_terminal(NonTerminalKind::TextBindingOpt0, children);
6158        TextBindingOpt0Node { node_id, builder }
6159    }
6160}
6161#[derive(bon::Builder)]
6162pub struct TextBindingOpt1Constructor {
6163    grammar_newline: Option<GrammarNewlineNode>,
6164}
6165impl TextBindingOpt1Constructor {
6166    pub fn build(self) -> TextBindingOpt1Node {
6167        let mut builder = CstBuilder::new();
6168        let children = if let Some(child) = self.grammar_newline {
6169            vec![builder.embed(child.builder)]
6170        } else {
6171            Vec::<BuilderNodeId>::new()
6172        };
6173        let node_id = builder.non_terminal(NonTerminalKind::TextBindingOpt1, children);
6174        TextBindingOpt1Node { node_id, builder }
6175    }
6176}
6177#[derive(bon::Builder)]
6178pub struct TextStartConstructor {
6179    text_start: TextStartToken,
6180}
6181impl TextStartConstructor {
6182    pub fn build(self) -> TextStartNode {
6183        let mut builder = CstBuilder::new();
6184        let text_start = builder.embed(self.text_start.builder);
6185        let node_id = builder.non_terminal(NonTerminalKind::TextStart, vec![text_start]);
6186        TextStartNode { node_id, builder }
6187    }
6188}
6189pub enum TopLevelBindingConstructor {
6190    ValueBinding(ValueBindingNode),
6191    TextBinding(TextBindingNode),
6192}
6193impl TopLevelBindingConstructor {
6194    pub fn build(self) -> TopLevelBindingNode {
6195        let mut builder = CstBuilder::new();
6196        let child_id = match self {
6197            Self::ValueBinding(node) => builder.embed(node.builder),
6198            Self::TextBinding(node) => builder.embed(node.builder),
6199        };
6200        let node_id = builder.non_terminal(NonTerminalKind::TopLevelBinding, vec![child_id]);
6201        TopLevelBindingNode { node_id, builder }
6202    }
6203}
6204#[derive(bon::Builder)]
6205pub struct TrueConstructor {
6206    r#true: TrueToken,
6207}
6208impl TrueConstructor {
6209    pub fn build(self) -> TrueNode {
6210        let mut builder = CstBuilder::new();
6211        let r#true = builder.embed(self.r#true.builder);
6212        let node_id = builder.non_terminal(NonTerminalKind::True, vec![r#true]);
6213        TrueNode { node_id, builder }
6214    }
6215}
6216#[derive(bon::Builder)]
6217pub struct TupleConstructor {
6218    l_paren: LParenNode,
6219    tuple_opt: TupleOptNode,
6220    r_paren: RParenNode,
6221}
6222impl TupleConstructor {
6223    pub fn build(self) -> TupleNode {
6224        let mut builder = CstBuilder::new();
6225        let l_paren = builder.embed(self.l_paren.builder);
6226        let tuple_opt = builder.embed(self.tuple_opt.builder);
6227        let r_paren = builder.embed(self.r_paren.builder);
6228        let node_id =
6229            builder.non_terminal(NonTerminalKind::Tuple, vec![l_paren, tuple_opt, r_paren]);
6230        TupleNode { node_id, builder }
6231    }
6232}
6233#[derive(bon::Builder)]
6234pub struct TupleElementsConstructor {
6235    value: ValueNode,
6236    tuple_elements_opt: TupleElementsOptNode,
6237}
6238impl TupleElementsConstructor {
6239    pub fn build(self) -> TupleElementsNode {
6240        let mut builder = CstBuilder::new();
6241        let value = builder.embed(self.value.builder);
6242        let tuple_elements_opt = builder.embed(self.tuple_elements_opt.builder);
6243        let node_id = builder.non_terminal(
6244            NonTerminalKind::TupleElements,
6245            vec![value, tuple_elements_opt],
6246        );
6247        TupleElementsNode { node_id, builder }
6248    }
6249}
6250#[derive(bon::Builder)]
6251pub struct TupleElementsOptConstructor {
6252    tuple_elements_tail: Option<TupleElementsTailNode>,
6253}
6254impl TupleElementsOptConstructor {
6255    pub fn build(self) -> TupleElementsOptNode {
6256        let mut builder = CstBuilder::new();
6257        let children = if let Some(child) = self.tuple_elements_tail {
6258            vec![builder.embed(child.builder)]
6259        } else {
6260            Vec::<BuilderNodeId>::new()
6261        };
6262        let node_id = builder.non_terminal(NonTerminalKind::TupleElementsOpt, children);
6263        TupleElementsOptNode { node_id, builder }
6264    }
6265}
6266#[derive(bon::Builder)]
6267pub struct TupleElementsTailConstructor {
6268    comma: CommaNode,
6269    tuple_elements_tail_opt: TupleElementsTailOptNode,
6270}
6271impl TupleElementsTailConstructor {
6272    pub fn build(self) -> TupleElementsTailNode {
6273        let mut builder = CstBuilder::new();
6274        let comma = builder.embed(self.comma.builder);
6275        let tuple_elements_tail_opt = builder.embed(self.tuple_elements_tail_opt.builder);
6276        let node_id = builder.non_terminal(
6277            NonTerminalKind::TupleElementsTail,
6278            vec![comma, tuple_elements_tail_opt],
6279        );
6280        TupleElementsTailNode { node_id, builder }
6281    }
6282}
6283#[derive(bon::Builder)]
6284pub struct TupleElementsTailOptConstructor {
6285    tuple_elements: Option<TupleElementsNode>,
6286}
6287impl TupleElementsTailOptConstructor {
6288    pub fn build(self) -> TupleElementsTailOptNode {
6289        let mut builder = CstBuilder::new();
6290        let children = if let Some(child) = self.tuple_elements {
6291            vec![builder.embed(child.builder)]
6292        } else {
6293            Vec::<BuilderNodeId>::new()
6294        };
6295        let node_id = builder.non_terminal(NonTerminalKind::TupleElementsTailOpt, children);
6296        TupleElementsTailOptNode { node_id, builder }
6297    }
6298}
6299#[derive(bon::Builder)]
6300pub struct TupleIndexConstructor {
6301    hash: HashToken,
6302    integer: IntegerNode,
6303}
6304impl TupleIndexConstructor {
6305    pub fn build(self) -> TupleIndexNode {
6306        let mut builder = CstBuilder::new();
6307        let hash = builder.embed(self.hash.builder);
6308        let integer = builder.embed(self.integer.builder);
6309        let node_id = builder.non_terminal(NonTerminalKind::TupleIndex, vec![hash, integer]);
6310        TupleIndexNode { node_id, builder }
6311    }
6312}
6313#[derive(bon::Builder)]
6314pub struct TupleOptConstructor {
6315    tuple_elements: Option<TupleElementsNode>,
6316}
6317impl TupleOptConstructor {
6318    pub fn build(self) -> TupleOptNode {
6319        let mut builder = CstBuilder::new();
6320        let children = if let Some(child) = self.tuple_elements {
6321            vec![builder.embed(child.builder)]
6322        } else {
6323            Vec::<BuilderNodeId>::new()
6324        };
6325        let node_id = builder.non_terminal(NonTerminalKind::TupleOpt, children);
6326        TupleOptNode { node_id, builder }
6327    }
6328}
6329pub enum ValueConstructor {
6330    Object(ObjectNode),
6331    Array(ArrayNode),
6332    Tuple(TupleNode),
6333    Number(NumberNode),
6334    Boolean(BooleanNode),
6335    Null(NullNode),
6336    Strings(StringsNode),
6337    Hole(HoleNode),
6338    CodeBlock(CodeBlockNode),
6339    InlineCode(InlineCodeNode),
6340}
6341impl ValueConstructor {
6342    pub fn build(self) -> ValueNode {
6343        let mut builder = CstBuilder::new();
6344        let child_id = match self {
6345            Self::Object(node) => builder.embed(node.builder),
6346            Self::Array(node) => builder.embed(node.builder),
6347            Self::Tuple(node) => builder.embed(node.builder),
6348            Self::Number(node) => builder.embed(node.builder),
6349            Self::Boolean(node) => builder.embed(node.builder),
6350            Self::Null(node) => builder.embed(node.builder),
6351            Self::Strings(node) => builder.embed(node.builder),
6352            Self::Hole(node) => builder.embed(node.builder),
6353            Self::CodeBlock(node) => builder.embed(node.builder),
6354            Self::InlineCode(node) => builder.embed(node.builder),
6355        };
6356        let node_id = builder.non_terminal(NonTerminalKind::Value, vec![child_id]);
6357        ValueNode { node_id, builder }
6358    }
6359}
6360#[derive(bon::Builder)]
6361pub struct ValueBindingConstructor {
6362    bind: BindNode,
6363    value: ValueNode,
6364}
6365impl ValueBindingConstructor {
6366    pub fn build(self) -> ValueBindingNode {
6367        let mut builder = CstBuilder::new();
6368        let bind = builder.embed(self.bind.builder);
6369        let value = builder.embed(self.value.builder);
6370        let node_id = builder.non_terminal(NonTerminalKind::ValueBinding, vec![bind, value]);
6371        ValueBindingNode { node_id, builder }
6372    }
6373}
6374#[derive(bon::Builder)]
6375pub struct WsConstructor {
6376    ws: WsToken,
6377}
6378impl WsConstructor {
6379    pub fn build(self) -> WsNode {
6380        let mut builder = CstBuilder::new();
6381        let ws = builder.embed(self.ws.builder);
6382        let node_id = builder.non_terminal(NonTerminalKind::Ws, vec![ws]);
6383        WsNode { node_id, builder }
6384    }
6385}
6386#[derive(bon::Builder)]
6387pub struct RootConstructor {
6388    eure: EureNode,
6389}
6390impl RootConstructor {
6391    pub fn build(self) -> RootNode {
6392        let mut builder = CstBuilder::new();
6393        let eure = builder.embed(self.eure.builder);
6394        let node_id = builder.non_terminal(NonTerminalKind::Root, vec![eure]);
6395        RootNode { node_id, builder }
6396    }
6397}
6398pub mod terminals {
6399    use super::*;
6400    pub fn hash() -> HashToken {
6401        let mut builder = CstBuilder::new();
6402        let node_id = builder.terminal(TerminalKind::Hash, "");
6403        HashToken { node_id, builder }
6404    }
6405    pub fn map_bind() -> MapBindToken {
6406        let mut builder = CstBuilder::new();
6407        let node_id = builder.terminal(TerminalKind::MapBind, "");
6408        MapBindToken { node_id, builder }
6409    }
6410    pub fn integer(value: &str) -> IntegerToken {
6411        let mut builder = CstBuilder::new();
6412        let node_id = builder.terminal(TerminalKind::Integer, value);
6413        IntegerToken { node_id, builder }
6414    }
6415    pub fn float() -> FloatToken {
6416        let mut builder = CstBuilder::new();
6417        let node_id = builder.terminal(TerminalKind::Float, "");
6418        FloatToken { node_id, builder }
6419    }
6420    pub fn inf() -> InfToken {
6421        let mut builder = CstBuilder::new();
6422        let node_id = builder.terminal(TerminalKind::Inf, "");
6423        InfToken { node_id, builder }
6424    }
6425    pub fn na_n() -> NaNToken {
6426        let mut builder = CstBuilder::new();
6427        let node_id = builder.terminal(TerminalKind::NaN, "");
6428        NaNToken { node_id, builder }
6429    }
6430    pub fn r#true() -> TrueToken {
6431        let mut builder = CstBuilder::new();
6432        let node_id = builder.terminal(TerminalKind::True, "true");
6433        TrueToken { node_id, builder }
6434    }
6435    pub fn r#false() -> FalseToken {
6436        let mut builder = CstBuilder::new();
6437        let node_id = builder.terminal(TerminalKind::False, "false");
6438        FalseToken { node_id, builder }
6439    }
6440    pub fn null() -> NullToken {
6441        let mut builder = CstBuilder::new();
6442        let node_id = builder.terminal(TerminalKind::Null, "null");
6443        NullToken { node_id, builder }
6444    }
6445    pub fn hole() -> HoleToken {
6446        let mut builder = CstBuilder::new();
6447        let node_id = builder.terminal(TerminalKind::Hole, "!");
6448        HoleToken { node_id, builder }
6449    }
6450    pub fn str(value: &str) -> StrToken {
6451        let mut builder = CstBuilder::new();
6452        let node_id = builder.terminal(TerminalKind::Str, value);
6453        StrToken { node_id, builder }
6454    }
6455    pub fn lit_str() -> LitStrToken {
6456        let mut builder = CstBuilder::new();
6457        let node_id = builder.terminal(TerminalKind::LitStr, "");
6458        LitStrToken { node_id, builder }
6459    }
6460    pub fn text(value: &str) -> TextToken {
6461        let mut builder = CstBuilder::new();
6462        let node_id = builder.terminal(TerminalKind::Text, value);
6463        TextToken { node_id, builder }
6464    }
6465    pub fn inline_code_1() -> InlineCode1Token {
6466        let mut builder = CstBuilder::new();
6467        let node_id = builder.terminal(TerminalKind::InlineCode1, "");
6468        InlineCode1Token { node_id, builder }
6469    }
6470    pub fn lit_str_3_start() -> LitStr3StartToken {
6471        let mut builder = CstBuilder::new();
6472        let node_id = builder.terminal(TerminalKind::LitStr3Start, "");
6473        LitStr3StartToken { node_id, builder }
6474    }
6475    pub fn lit_str_2_start() -> LitStr2StartToken {
6476        let mut builder = CstBuilder::new();
6477        let node_id = builder.terminal(TerminalKind::LitStr2Start, "");
6478        LitStr2StartToken { node_id, builder }
6479    }
6480    pub fn lit_str_1_start() -> LitStr1StartToken {
6481        let mut builder = CstBuilder::new();
6482        let node_id = builder.terminal(TerminalKind::LitStr1Start, "");
6483        LitStr1StartToken { node_id, builder }
6484    }
6485    pub fn delim_code_start_3() -> DelimCodeStart3Token {
6486        let mut builder = CstBuilder::new();
6487        let node_id = builder.terminal(TerminalKind::DelimCodeStart3, "");
6488        DelimCodeStart3Token { node_id, builder }
6489    }
6490    pub fn delim_code_start_2() -> DelimCodeStart2Token {
6491        let mut builder = CstBuilder::new();
6492        let node_id = builder.terminal(TerminalKind::DelimCodeStart2, "");
6493        DelimCodeStart2Token { node_id, builder }
6494    }
6495    pub fn delim_code_start_1() -> DelimCodeStart1Token {
6496        let mut builder = CstBuilder::new();
6497        let node_id = builder.terminal(TerminalKind::DelimCodeStart1, "");
6498        DelimCodeStart1Token { node_id, builder }
6499    }
6500    pub fn code_block_start_3() -> CodeBlockStart3Token {
6501        let mut builder = CstBuilder::new();
6502        let node_id = builder.terminal(TerminalKind::CodeBlockStart3, "");
6503        CodeBlockStart3Token { node_id, builder }
6504    }
6505    pub fn code_block_start_4() -> CodeBlockStart4Token {
6506        let mut builder = CstBuilder::new();
6507        let node_id = builder.terminal(TerminalKind::CodeBlockStart4, "");
6508        CodeBlockStart4Token { node_id, builder }
6509    }
6510    pub fn code_block_start_5() -> CodeBlockStart5Token {
6511        let mut builder = CstBuilder::new();
6512        let node_id = builder.terminal(TerminalKind::CodeBlockStart5, "");
6513        CodeBlockStart5Token { node_id, builder }
6514    }
6515    pub fn code_block_start_6() -> CodeBlockStart6Token {
6516        let mut builder = CstBuilder::new();
6517        let node_id = builder.terminal(TerminalKind::CodeBlockStart6, "");
6518        CodeBlockStart6Token { node_id, builder }
6519    }
6520    pub fn code_block_end_3() -> CodeBlockEnd3Token {
6521        let mut builder = CstBuilder::new();
6522        let node_id = builder.terminal(TerminalKind::CodeBlockEnd3, "");
6523        CodeBlockEnd3Token { node_id, builder }
6524    }
6525    pub fn backtick_2() -> Backtick2Token {
6526        let mut builder = CstBuilder::new();
6527        let node_id = builder.terminal(TerminalKind::Backtick2, "");
6528        Backtick2Token { node_id, builder }
6529    }
6530    pub fn code_block_end_4() -> CodeBlockEnd4Token {
6531        let mut builder = CstBuilder::new();
6532        let node_id = builder.terminal(TerminalKind::CodeBlockEnd4, "");
6533        CodeBlockEnd4Token { node_id, builder }
6534    }
6535    pub fn backtick_3() -> Backtick3Token {
6536        let mut builder = CstBuilder::new();
6537        let node_id = builder.terminal(TerminalKind::Backtick3, "");
6538        Backtick3Token { node_id, builder }
6539    }
6540    pub fn code_block_end_5() -> CodeBlockEnd5Token {
6541        let mut builder = CstBuilder::new();
6542        let node_id = builder.terminal(TerminalKind::CodeBlockEnd5, "");
6543        CodeBlockEnd5Token { node_id, builder }
6544    }
6545    pub fn backtick_4() -> Backtick4Token {
6546        let mut builder = CstBuilder::new();
6547        let node_id = builder.terminal(TerminalKind::Backtick4, "");
6548        Backtick4Token { node_id, builder }
6549    }
6550    pub fn code_block_end_6() -> CodeBlockEnd6Token {
6551        let mut builder = CstBuilder::new();
6552        let node_id = builder.terminal(TerminalKind::CodeBlockEnd6, "");
6553        CodeBlockEnd6Token { node_id, builder }
6554    }
6555    pub fn backtick_5() -> Backtick5Token {
6556        let mut builder = CstBuilder::new();
6557        let node_id = builder.terminal(TerminalKind::Backtick5, "");
6558        Backtick5Token { node_id, builder }
6559    }
6560    pub fn no_backtick() -> NoBacktickToken {
6561        let mut builder = CstBuilder::new();
6562        let node_id = builder.terminal(TerminalKind::NoBacktick, "");
6563        NoBacktickToken { node_id, builder }
6564    }
6565    pub fn lit_str_3_end() -> LitStr3EndToken {
6566        let mut builder = CstBuilder::new();
6567        let node_id = builder.terminal(TerminalKind::LitStr3End, "");
6568        LitStr3EndToken { node_id, builder }
6569    }
6570    pub fn lit_str_2_end() -> LitStr2EndToken {
6571        let mut builder = CstBuilder::new();
6572        let node_id = builder.terminal(TerminalKind::LitStr2End, "");
6573        LitStr2EndToken { node_id, builder }
6574    }
6575    pub fn lit_str_1_end() -> LitStr1EndToken {
6576        let mut builder = CstBuilder::new();
6577        let node_id = builder.terminal(TerminalKind::LitStr1End, "");
6578        LitStr1EndToken { node_id, builder }
6579    }
6580    pub fn s_quote() -> SQuoteToken {
6581        let mut builder = CstBuilder::new();
6582        let node_id = builder.terminal(TerminalKind::SQuote, "");
6583        SQuoteToken { node_id, builder }
6584    }
6585    pub fn no_s_quote() -> NoSQuoteToken {
6586        let mut builder = CstBuilder::new();
6587        let node_id = builder.terminal(TerminalKind::NoSQuote, "");
6588        NoSQuoteToken { node_id, builder }
6589    }
6590    pub fn delim_code_end_3() -> DelimCodeEnd3Token {
6591        let mut builder = CstBuilder::new();
6592        let node_id = builder.terminal(TerminalKind::DelimCodeEnd3, "");
6593        DelimCodeEnd3Token { node_id, builder }
6594    }
6595    pub fn delim_code_end_2() -> DelimCodeEnd2Token {
6596        let mut builder = CstBuilder::new();
6597        let node_id = builder.terminal(TerminalKind::DelimCodeEnd2, "");
6598        DelimCodeEnd2Token { node_id, builder }
6599    }
6600    pub fn delim_code_end_1() -> DelimCodeEnd1Token {
6601        let mut builder = CstBuilder::new();
6602        let node_id = builder.terminal(TerminalKind::DelimCodeEnd1, "");
6603        DelimCodeEnd1Token { node_id, builder }
6604    }
6605    pub fn backtick_delim() -> BacktickDelimToken {
6606        let mut builder = CstBuilder::new();
6607        let node_id = builder.terminal(TerminalKind::BacktickDelim, "");
6608        BacktickDelimToken { node_id, builder }
6609    }
6610    pub fn grammar_newline() -> GrammarNewlineToken {
6611        let mut builder = CstBuilder::new();
6612        let node_id = builder.terminal(TerminalKind::GrammarNewline, "\n");
6613        GrammarNewlineToken { node_id, builder }
6614    }
6615    pub fn ws() -> WsToken {
6616        let mut builder = CstBuilder::new();
6617        let node_id = builder.terminal(TerminalKind::Ws, " ");
6618        WsToken { node_id, builder }
6619    }
6620    pub fn at() -> AtToken {
6621        let mut builder = CstBuilder::new();
6622        let node_id = builder.terminal(TerminalKind::At, "@");
6623        AtToken { node_id, builder }
6624    }
6625    pub fn dollar() -> DollarToken {
6626        let mut builder = CstBuilder::new();
6627        let node_id = builder.terminal(TerminalKind::Dollar, "$");
6628        DollarToken { node_id, builder }
6629    }
6630    pub fn dot() -> DotToken {
6631        let mut builder = CstBuilder::new();
6632        let node_id = builder.terminal(TerminalKind::Dot, ".");
6633        DotToken { node_id, builder }
6634    }
6635    pub fn l_brace() -> LBraceToken {
6636        let mut builder = CstBuilder::new();
6637        let node_id = builder.terminal(TerminalKind::LBrace, "{");
6638        LBraceToken { node_id, builder }
6639    }
6640    pub fn r_brace() -> RBraceToken {
6641        let mut builder = CstBuilder::new();
6642        let node_id = builder.terminal(TerminalKind::RBrace, "}");
6643        RBraceToken { node_id, builder }
6644    }
6645    pub fn l_bracket() -> LBracketToken {
6646        let mut builder = CstBuilder::new();
6647        let node_id = builder.terminal(TerminalKind::LBracket, "[");
6648        LBracketToken { node_id, builder }
6649    }
6650    pub fn r_bracket() -> RBracketToken {
6651        let mut builder = CstBuilder::new();
6652        let node_id = builder.terminal(TerminalKind::RBracket, "]");
6653        RBracketToken { node_id, builder }
6654    }
6655    pub fn l_paren() -> LParenToken {
6656        let mut builder = CstBuilder::new();
6657        let node_id = builder.terminal(TerminalKind::LParen, "");
6658        LParenToken { node_id, builder }
6659    }
6660    pub fn r_paren() -> RParenToken {
6661        let mut builder = CstBuilder::new();
6662        let node_id = builder.terminal(TerminalKind::RParen, "");
6663        RParenToken { node_id, builder }
6664    }
6665    pub fn newline_bind() -> NewlineBindToken {
6666        let mut builder = CstBuilder::new();
6667        let node_id = builder.terminal(TerminalKind::NewlineBind, "");
6668        NewlineBindToken { node_id, builder }
6669    }
6670    pub fn bind() -> BindToken {
6671        let mut builder = CstBuilder::new();
6672        let node_id = builder.terminal(TerminalKind::Bind, "=");
6673        BindToken { node_id, builder }
6674    }
6675    pub fn comma() -> CommaToken {
6676        let mut builder = CstBuilder::new();
6677        let node_id = builder.terminal(TerminalKind::Comma, ",");
6678        CommaToken { node_id, builder }
6679    }
6680    pub fn esc() -> EscToken {
6681        let mut builder = CstBuilder::new();
6682        let node_id = builder.terminal(TerminalKind::Esc, "\\\\");
6683        EscToken { node_id, builder }
6684    }
6685    pub fn newline_text_start() -> NewlineTextStartToken {
6686        let mut builder = CstBuilder::new();
6687        let node_id = builder.terminal(TerminalKind::NewlineTextStart, "");
6688        NewlineTextStartToken { node_id, builder }
6689    }
6690    pub fn text_start() -> TextStartToken {
6691        let mut builder = CstBuilder::new();
6692        let node_id = builder.terminal(TerminalKind::TextStart, "");
6693        TextStartToken { node_id, builder }
6694    }
6695    pub fn ident(name: &str) -> IdentToken {
6696        let mut builder = CstBuilder::new();
6697        let node_id = builder.terminal(TerminalKind::Ident, name);
6698        IdentToken { node_id, builder }
6699    }
6700}
eure_tree/constructors.rs

eure_tree/
constructors.rs
