Skip to main content

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 Bind terminal
907#[derive(Debug, Clone)]
908pub struct BindToken {
909    pub(super) node_id: BuilderNodeId,
910    pub(super) builder: CstBuilder,
911}
912impl BindToken {
913    /// Consume this token and return its builder
914    pub fn into_builder(self) -> CstBuilder {
915        self.builder
916    }
917}
918impl From<BindToken> for BuilderNodeId {
919    fn from(token: BindToken) -> Self {
920        token.node_id
921    }
922}
923///Branded type for Comma terminal
924#[derive(Debug, Clone)]
925pub struct CommaToken {
926    pub(super) node_id: BuilderNodeId,
927    pub(super) builder: CstBuilder,
928}
929impl CommaToken {
930    /// Consume this token and return its builder
931    pub fn into_builder(self) -> CstBuilder {
932        self.builder
933    }
934}
935impl From<CommaToken> for BuilderNodeId {
936    fn from(token: CommaToken) -> Self {
937        token.node_id
938    }
939}
940///Branded type for Esc terminal
941#[derive(Debug, Clone)]
942pub struct EscToken {
943    pub(super) node_id: BuilderNodeId,
944    pub(super) builder: CstBuilder,
945}
946impl EscToken {
947    /// Consume this token and return its builder
948    pub fn into_builder(self) -> CstBuilder {
949        self.builder
950    }
951}
952impl From<EscToken> for BuilderNodeId {
953    fn from(token: EscToken) -> Self {
954        token.node_id
955    }
956}
957///Branded type for TextStart terminal
958#[derive(Debug, Clone)]
959pub struct TextStartToken {
960    pub(super) node_id: BuilderNodeId,
961    pub(super) builder: CstBuilder,
962}
963impl TextStartToken {
964    /// Consume this token and return its builder
965    pub fn into_builder(self) -> CstBuilder {
966        self.builder
967    }
968}
969impl From<TextStartToken> for BuilderNodeId {
970    fn from(token: TextStartToken) -> Self {
971        token.node_id
972    }
973}
974///Branded type for Ident terminal
975#[derive(Debug, Clone)]
976pub struct IdentToken {
977    pub(super) node_id: BuilderNodeId,
978    pub(super) builder: CstBuilder,
979}
980impl IdentToken {
981    /// Consume this token and return its builder
982    pub fn into_builder(self) -> CstBuilder {
983        self.builder
984    }
985}
986impl From<IdentToken> for BuilderNodeId {
987    fn from(token: IdentToken) -> Self {
988        token.node_id
989    }
990}
991///Branded type for Array non-terminal
992#[derive(Debug, Clone)]
993pub struct ArrayNode {
994    pub(super) node_id: BuilderNodeId,
995    pub(super) builder: CstBuilder,
996}
997impl ArrayNode {
998    /// Consume this node and return its builder
999    pub fn into_builder(self) -> CstBuilder {
1000        self.builder
1001    }
1002}
1003impl From<ArrayNode> for BuilderNodeId {
1004    fn from(node: ArrayNode) -> Self {
1005        node.node_id
1006    }
1007}
1008///Branded type for ArrayBegin non-terminal
1009#[derive(Debug, Clone)]
1010pub struct ArrayBeginNode {
1011    pub(super) node_id: BuilderNodeId,
1012    pub(super) builder: CstBuilder,
1013}
1014impl ArrayBeginNode {
1015    /// Consume this node and return its builder
1016    pub fn into_builder(self) -> CstBuilder {
1017        self.builder
1018    }
1019}
1020impl From<ArrayBeginNode> for BuilderNodeId {
1021    fn from(node: ArrayBeginNode) -> Self {
1022        node.node_id
1023    }
1024}
1025///Branded type for ArrayElements non-terminal
1026#[derive(Debug, Clone)]
1027pub struct ArrayElementsNode {
1028    pub(super) node_id: BuilderNodeId,
1029    pub(super) builder: CstBuilder,
1030}
1031impl ArrayElementsNode {
1032    /// Consume this node and return its builder
1033    pub fn into_builder(self) -> CstBuilder {
1034        self.builder
1035    }
1036}
1037impl From<ArrayElementsNode> for BuilderNodeId {
1038    fn from(node: ArrayElementsNode) -> Self {
1039        node.node_id
1040    }
1041}
1042///Branded type for ArrayElementsOpt non-terminal
1043#[derive(Debug, Clone)]
1044pub struct ArrayElementsOptNode {
1045    pub(super) node_id: BuilderNodeId,
1046    pub(super) builder: CstBuilder,
1047}
1048impl ArrayElementsOptNode {
1049    /// Consume this node and return its builder
1050    pub fn into_builder(self) -> CstBuilder {
1051        self.builder
1052    }
1053}
1054impl From<ArrayElementsOptNode> for BuilderNodeId {
1055    fn from(node: ArrayElementsOptNode) -> Self {
1056        node.node_id
1057    }
1058}
1059///Branded type for ArrayElementsTail non-terminal
1060#[derive(Debug, Clone)]
1061pub struct ArrayElementsTailNode {
1062    pub(super) node_id: BuilderNodeId,
1063    pub(super) builder: CstBuilder,
1064}
1065impl ArrayElementsTailNode {
1066    /// Consume this node and return its builder
1067    pub fn into_builder(self) -> CstBuilder {
1068        self.builder
1069    }
1070}
1071impl From<ArrayElementsTailNode> for BuilderNodeId {
1072    fn from(node: ArrayElementsTailNode) -> Self {
1073        node.node_id
1074    }
1075}
1076///Branded type for ArrayElementsTailOpt non-terminal
1077#[derive(Debug, Clone)]
1078pub struct ArrayElementsTailOptNode {
1079    pub(super) node_id: BuilderNodeId,
1080    pub(super) builder: CstBuilder,
1081}
1082impl ArrayElementsTailOptNode {
1083    /// Consume this node and return its builder
1084    pub fn into_builder(self) -> CstBuilder {
1085        self.builder
1086    }
1087}
1088impl From<ArrayElementsTailOptNode> for BuilderNodeId {
1089    fn from(node: ArrayElementsTailOptNode) -> Self {
1090        node.node_id
1091    }
1092}
1093///Branded type for ArrayEnd non-terminal
1094#[derive(Debug, Clone)]
1095pub struct ArrayEndNode {
1096    pub(super) node_id: BuilderNodeId,
1097    pub(super) builder: CstBuilder,
1098}
1099impl ArrayEndNode {
1100    /// Consume this node and return its builder
1101    pub fn into_builder(self) -> CstBuilder {
1102        self.builder
1103    }
1104}
1105impl From<ArrayEndNode> for BuilderNodeId {
1106    fn from(node: ArrayEndNode) -> Self {
1107        node.node_id
1108    }
1109}
1110///Branded type for ArrayMarker non-terminal
1111#[derive(Debug, Clone)]
1112pub struct ArrayMarkerNode {
1113    pub(super) node_id: BuilderNodeId,
1114    pub(super) builder: CstBuilder,
1115}
1116impl ArrayMarkerNode {
1117    /// Consume this node and return its builder
1118    pub fn into_builder(self) -> CstBuilder {
1119        self.builder
1120    }
1121}
1122impl From<ArrayMarkerNode> for BuilderNodeId {
1123    fn from(node: ArrayMarkerNode) -> Self {
1124        node.node_id
1125    }
1126}
1127///Branded type for ArrayMarkerOpt non-terminal
1128#[derive(Debug, Clone)]
1129pub struct ArrayMarkerOptNode {
1130    pub(super) node_id: BuilderNodeId,
1131    pub(super) builder: CstBuilder,
1132}
1133impl ArrayMarkerOptNode {
1134    /// Consume this node and return its builder
1135    pub fn into_builder(self) -> CstBuilder {
1136        self.builder
1137    }
1138}
1139impl From<ArrayMarkerOptNode> for BuilderNodeId {
1140    fn from(node: ArrayMarkerOptNode) -> Self {
1141        node.node_id
1142    }
1143}
1144///Branded type for ArrayOpt non-terminal
1145#[derive(Debug, Clone)]
1146pub struct ArrayOptNode {
1147    pub(super) node_id: BuilderNodeId,
1148    pub(super) builder: CstBuilder,
1149}
1150impl ArrayOptNode {
1151    /// Consume this node and return its builder
1152    pub fn into_builder(self) -> CstBuilder {
1153        self.builder
1154    }
1155}
1156impl From<ArrayOptNode> for BuilderNodeId {
1157    fn from(node: ArrayOptNode) -> Self {
1158        node.node_id
1159    }
1160}
1161///Branded type for At non-terminal
1162#[derive(Debug, Clone)]
1163pub struct AtNode {
1164    pub(super) node_id: BuilderNodeId,
1165    pub(super) builder: CstBuilder,
1166}
1167impl AtNode {
1168    /// Consume this node and return its builder
1169    pub fn into_builder(self) -> CstBuilder {
1170        self.builder
1171    }
1172}
1173impl From<AtNode> for BuilderNodeId {
1174    fn from(node: AtNode) -> Self {
1175        node.node_id
1176    }
1177}
1178///Branded type for Backtick2 non-terminal
1179#[derive(Debug, Clone)]
1180pub struct Backtick2Node {
1181    pub(super) node_id: BuilderNodeId,
1182    pub(super) builder: CstBuilder,
1183}
1184impl Backtick2Node {
1185    /// Consume this node and return its builder
1186    pub fn into_builder(self) -> CstBuilder {
1187        self.builder
1188    }
1189}
1190impl From<Backtick2Node> for BuilderNodeId {
1191    fn from(node: Backtick2Node) -> Self {
1192        node.node_id
1193    }
1194}
1195///Branded type for Backtick3 non-terminal
1196#[derive(Debug, Clone)]
1197pub struct Backtick3Node {
1198    pub(super) node_id: BuilderNodeId,
1199    pub(super) builder: CstBuilder,
1200}
1201impl Backtick3Node {
1202    /// Consume this node and return its builder
1203    pub fn into_builder(self) -> CstBuilder {
1204        self.builder
1205    }
1206}
1207impl From<Backtick3Node> for BuilderNodeId {
1208    fn from(node: Backtick3Node) -> Self {
1209        node.node_id
1210    }
1211}
1212///Branded type for Backtick4 non-terminal
1213#[derive(Debug, Clone)]
1214pub struct Backtick4Node {
1215    pub(super) node_id: BuilderNodeId,
1216    pub(super) builder: CstBuilder,
1217}
1218impl Backtick4Node {
1219    /// Consume this node and return its builder
1220    pub fn into_builder(self) -> CstBuilder {
1221        self.builder
1222    }
1223}
1224impl From<Backtick4Node> for BuilderNodeId {
1225    fn from(node: Backtick4Node) -> Self {
1226        node.node_id
1227    }
1228}
1229///Branded type for Backtick5 non-terminal
1230#[derive(Debug, Clone)]
1231pub struct Backtick5Node {
1232    pub(super) node_id: BuilderNodeId,
1233    pub(super) builder: CstBuilder,
1234}
1235impl Backtick5Node {
1236    /// Consume this node and return its builder
1237    pub fn into_builder(self) -> CstBuilder {
1238        self.builder
1239    }
1240}
1241impl From<Backtick5Node> for BuilderNodeId {
1242    fn from(node: Backtick5Node) -> Self {
1243        node.node_id
1244    }
1245}
1246///Branded type for BacktickDelim non-terminal
1247#[derive(Debug, Clone)]
1248pub struct BacktickDelimNode {
1249    pub(super) node_id: BuilderNodeId,
1250    pub(super) builder: CstBuilder,
1251}
1252impl BacktickDelimNode {
1253    /// Consume this node and return its builder
1254    pub fn into_builder(self) -> CstBuilder {
1255        self.builder
1256    }
1257}
1258impl From<BacktickDelimNode> for BuilderNodeId {
1259    fn from(node: BacktickDelimNode) -> Self {
1260        node.node_id
1261    }
1262}
1263///Branded type for Begin non-terminal
1264#[derive(Debug, Clone)]
1265pub struct BeginNode {
1266    pub(super) node_id: BuilderNodeId,
1267    pub(super) builder: CstBuilder,
1268}
1269impl BeginNode {
1270    /// Consume this node and return its builder
1271    pub fn into_builder(self) -> CstBuilder {
1272        self.builder
1273    }
1274}
1275impl From<BeginNode> for BuilderNodeId {
1276    fn from(node: BeginNode) -> Self {
1277        node.node_id
1278    }
1279}
1280///Branded type for Bind non-terminal
1281#[derive(Debug, Clone)]
1282pub struct BindNode {
1283    pub(super) node_id: BuilderNodeId,
1284    pub(super) builder: CstBuilder,
1285}
1286impl BindNode {
1287    /// Consume this node and return its builder
1288    pub fn into_builder(self) -> CstBuilder {
1289        self.builder
1290    }
1291}
1292impl From<BindNode> for BuilderNodeId {
1293    fn from(node: BindNode) -> Self {
1294        node.node_id
1295    }
1296}
1297///Branded type for Binding non-terminal
1298#[derive(Debug, Clone)]
1299pub struct BindingNode {
1300    pub(super) node_id: BuilderNodeId,
1301    pub(super) builder: CstBuilder,
1302}
1303impl BindingNode {
1304    /// Consume this node and return its builder
1305    pub fn into_builder(self) -> CstBuilder {
1306        self.builder
1307    }
1308}
1309impl From<BindingNode> for BuilderNodeId {
1310    fn from(node: BindingNode) -> Self {
1311        node.node_id
1312    }
1313}
1314///Branded type for BindingRhs non-terminal
1315#[derive(Debug, Clone)]
1316pub struct BindingRhsNode {
1317    pub(super) node_id: BuilderNodeId,
1318    pub(super) builder: CstBuilder,
1319}
1320impl BindingRhsNode {
1321    /// Consume this node and return its builder
1322    pub fn into_builder(self) -> CstBuilder {
1323        self.builder
1324    }
1325}
1326impl From<BindingRhsNode> for BuilderNodeId {
1327    fn from(node: BindingRhsNode) -> Self {
1328        node.node_id
1329    }
1330}
1331///Branded type for Boolean non-terminal
1332#[derive(Debug, Clone)]
1333pub struct BooleanNode {
1334    pub(super) node_id: BuilderNodeId,
1335    pub(super) builder: CstBuilder,
1336}
1337impl BooleanNode {
1338    /// Consume this node and return its builder
1339    pub fn into_builder(self) -> CstBuilder {
1340        self.builder
1341    }
1342}
1343impl From<BooleanNode> for BuilderNodeId {
1344    fn from(node: BooleanNode) -> Self {
1345        node.node_id
1346    }
1347}
1348///Branded type for CodeBlock non-terminal
1349#[derive(Debug, Clone)]
1350pub struct CodeBlockNode {
1351    pub(super) node_id: BuilderNodeId,
1352    pub(super) builder: CstBuilder,
1353}
1354impl CodeBlockNode {
1355    /// Consume this node and return its builder
1356    pub fn into_builder(self) -> CstBuilder {
1357        self.builder
1358    }
1359}
1360impl From<CodeBlockNode> for BuilderNodeId {
1361    fn from(node: CodeBlockNode) -> Self {
1362        node.node_id
1363    }
1364}
1365///Branded type for CodeBlock3 non-terminal
1366#[derive(Debug, Clone)]
1367pub struct CodeBlock3Node {
1368    pub(super) node_id: BuilderNodeId,
1369    pub(super) builder: CstBuilder,
1370}
1371impl CodeBlock3Node {
1372    /// Consume this node and return its builder
1373    pub fn into_builder(self) -> CstBuilder {
1374        self.builder
1375    }
1376}
1377impl From<CodeBlock3Node> for BuilderNodeId {
1378    fn from(node: CodeBlock3Node) -> Self {
1379        node.node_id
1380    }
1381}
1382///Branded type for CodeBlock3List non-terminal
1383#[derive(Debug, Clone)]
1384pub struct CodeBlock3ListNode {
1385    pub(super) node_id: BuilderNodeId,
1386    pub(super) builder: CstBuilder,
1387}
1388impl CodeBlock3ListNode {
1389    /// Consume this node and return its builder
1390    pub fn into_builder(self) -> CstBuilder {
1391        self.builder
1392    }
1393}
1394impl From<CodeBlock3ListNode> for BuilderNodeId {
1395    fn from(node: CodeBlock3ListNode) -> Self {
1396        node.node_id
1397    }
1398}
1399///Branded type for CodeBlock3ListGroup non-terminal
1400#[derive(Debug, Clone)]
1401pub struct CodeBlock3ListGroupNode {
1402    pub(super) node_id: BuilderNodeId,
1403    pub(super) builder: CstBuilder,
1404}
1405impl CodeBlock3ListGroupNode {
1406    /// Consume this node and return its builder
1407    pub fn into_builder(self) -> CstBuilder {
1408        self.builder
1409    }
1410}
1411impl From<CodeBlock3ListGroupNode> for BuilderNodeId {
1412    fn from(node: CodeBlock3ListGroupNode) -> Self {
1413        node.node_id
1414    }
1415}
1416///Branded type for CodeBlock4 non-terminal
1417#[derive(Debug, Clone)]
1418pub struct CodeBlock4Node {
1419    pub(super) node_id: BuilderNodeId,
1420    pub(super) builder: CstBuilder,
1421}
1422impl CodeBlock4Node {
1423    /// Consume this node and return its builder
1424    pub fn into_builder(self) -> CstBuilder {
1425        self.builder
1426    }
1427}
1428impl From<CodeBlock4Node> for BuilderNodeId {
1429    fn from(node: CodeBlock4Node) -> Self {
1430        node.node_id
1431    }
1432}
1433///Branded type for CodeBlock4List non-terminal
1434#[derive(Debug, Clone)]
1435pub struct CodeBlock4ListNode {
1436    pub(super) node_id: BuilderNodeId,
1437    pub(super) builder: CstBuilder,
1438}
1439impl CodeBlock4ListNode {
1440    /// Consume this node and return its builder
1441    pub fn into_builder(self) -> CstBuilder {
1442        self.builder
1443    }
1444}
1445impl From<CodeBlock4ListNode> for BuilderNodeId {
1446    fn from(node: CodeBlock4ListNode) -> Self {
1447        node.node_id
1448    }
1449}
1450///Branded type for CodeBlock4ListGroup non-terminal
1451#[derive(Debug, Clone)]
1452pub struct CodeBlock4ListGroupNode {
1453    pub(super) node_id: BuilderNodeId,
1454    pub(super) builder: CstBuilder,
1455}
1456impl CodeBlock4ListGroupNode {
1457    /// Consume this node and return its builder
1458    pub fn into_builder(self) -> CstBuilder {
1459        self.builder
1460    }
1461}
1462impl From<CodeBlock4ListGroupNode> for BuilderNodeId {
1463    fn from(node: CodeBlock4ListGroupNode) -> Self {
1464        node.node_id
1465    }
1466}
1467///Branded type for CodeBlock5 non-terminal
1468#[derive(Debug, Clone)]
1469pub struct CodeBlock5Node {
1470    pub(super) node_id: BuilderNodeId,
1471    pub(super) builder: CstBuilder,
1472}
1473impl CodeBlock5Node {
1474    /// Consume this node and return its builder
1475    pub fn into_builder(self) -> CstBuilder {
1476        self.builder
1477    }
1478}
1479impl From<CodeBlock5Node> for BuilderNodeId {
1480    fn from(node: CodeBlock5Node) -> Self {
1481        node.node_id
1482    }
1483}
1484///Branded type for CodeBlock5List non-terminal
1485#[derive(Debug, Clone)]
1486pub struct CodeBlock5ListNode {
1487    pub(super) node_id: BuilderNodeId,
1488    pub(super) builder: CstBuilder,
1489}
1490impl CodeBlock5ListNode {
1491    /// Consume this node and return its builder
1492    pub fn into_builder(self) -> CstBuilder {
1493        self.builder
1494    }
1495}
1496impl From<CodeBlock5ListNode> for BuilderNodeId {
1497    fn from(node: CodeBlock5ListNode) -> Self {
1498        node.node_id
1499    }
1500}
1501///Branded type for CodeBlock5ListGroup non-terminal
1502#[derive(Debug, Clone)]
1503pub struct CodeBlock5ListGroupNode {
1504    pub(super) node_id: BuilderNodeId,
1505    pub(super) builder: CstBuilder,
1506}
1507impl CodeBlock5ListGroupNode {
1508    /// Consume this node and return its builder
1509    pub fn into_builder(self) -> CstBuilder {
1510        self.builder
1511    }
1512}
1513impl From<CodeBlock5ListGroupNode> for BuilderNodeId {
1514    fn from(node: CodeBlock5ListGroupNode) -> Self {
1515        node.node_id
1516    }
1517}
1518///Branded type for CodeBlock6 non-terminal
1519#[derive(Debug, Clone)]
1520pub struct CodeBlock6Node {
1521    pub(super) node_id: BuilderNodeId,
1522    pub(super) builder: CstBuilder,
1523}
1524impl CodeBlock6Node {
1525    /// Consume this node and return its builder
1526    pub fn into_builder(self) -> CstBuilder {
1527        self.builder
1528    }
1529}
1530impl From<CodeBlock6Node> for BuilderNodeId {
1531    fn from(node: CodeBlock6Node) -> Self {
1532        node.node_id
1533    }
1534}
1535///Branded type for CodeBlock6List non-terminal
1536#[derive(Debug, Clone)]
1537pub struct CodeBlock6ListNode {
1538    pub(super) node_id: BuilderNodeId,
1539    pub(super) builder: CstBuilder,
1540}
1541impl CodeBlock6ListNode {
1542    /// Consume this node and return its builder
1543    pub fn into_builder(self) -> CstBuilder {
1544        self.builder
1545    }
1546}
1547impl From<CodeBlock6ListNode> for BuilderNodeId {
1548    fn from(node: CodeBlock6ListNode) -> Self {
1549        node.node_id
1550    }
1551}
1552///Branded type for CodeBlock6ListGroup non-terminal
1553#[derive(Debug, Clone)]
1554pub struct CodeBlock6ListGroupNode {
1555    pub(super) node_id: BuilderNodeId,
1556    pub(super) builder: CstBuilder,
1557}
1558impl CodeBlock6ListGroupNode {
1559    /// Consume this node and return its builder
1560    pub fn into_builder(self) -> CstBuilder {
1561        self.builder
1562    }
1563}
1564impl From<CodeBlock6ListGroupNode> for BuilderNodeId {
1565    fn from(node: CodeBlock6ListGroupNode) -> Self {
1566        node.node_id
1567    }
1568}
1569///Branded type for CodeBlockEnd3 non-terminal
1570#[derive(Debug, Clone)]
1571pub struct CodeBlockEnd3Node {
1572    pub(super) node_id: BuilderNodeId,
1573    pub(super) builder: CstBuilder,
1574}
1575impl CodeBlockEnd3Node {
1576    /// Consume this node and return its builder
1577    pub fn into_builder(self) -> CstBuilder {
1578        self.builder
1579    }
1580}
1581impl From<CodeBlockEnd3Node> for BuilderNodeId {
1582    fn from(node: CodeBlockEnd3Node) -> Self {
1583        node.node_id
1584    }
1585}
1586///Branded type for CodeBlockEnd4 non-terminal
1587#[derive(Debug, Clone)]
1588pub struct CodeBlockEnd4Node {
1589    pub(super) node_id: BuilderNodeId,
1590    pub(super) builder: CstBuilder,
1591}
1592impl CodeBlockEnd4Node {
1593    /// Consume this node and return its builder
1594    pub fn into_builder(self) -> CstBuilder {
1595        self.builder
1596    }
1597}
1598impl From<CodeBlockEnd4Node> for BuilderNodeId {
1599    fn from(node: CodeBlockEnd4Node) -> Self {
1600        node.node_id
1601    }
1602}
1603///Branded type for CodeBlockEnd5 non-terminal
1604#[derive(Debug, Clone)]
1605pub struct CodeBlockEnd5Node {
1606    pub(super) node_id: BuilderNodeId,
1607    pub(super) builder: CstBuilder,
1608}
1609impl CodeBlockEnd5Node {
1610    /// Consume this node and return its builder
1611    pub fn into_builder(self) -> CstBuilder {
1612        self.builder
1613    }
1614}
1615impl From<CodeBlockEnd5Node> for BuilderNodeId {
1616    fn from(node: CodeBlockEnd5Node) -> Self {
1617        node.node_id
1618    }
1619}
1620///Branded type for CodeBlockEnd6 non-terminal
1621#[derive(Debug, Clone)]
1622pub struct CodeBlockEnd6Node {
1623    pub(super) node_id: BuilderNodeId,
1624    pub(super) builder: CstBuilder,
1625}
1626impl CodeBlockEnd6Node {
1627    /// Consume this node and return its builder
1628    pub fn into_builder(self) -> CstBuilder {
1629        self.builder
1630    }
1631}
1632impl From<CodeBlockEnd6Node> for BuilderNodeId {
1633    fn from(node: CodeBlockEnd6Node) -> Self {
1634        node.node_id
1635    }
1636}
1637///Branded type for CodeBlockStart3 non-terminal
1638#[derive(Debug, Clone)]
1639pub struct CodeBlockStart3Node {
1640    pub(super) node_id: BuilderNodeId,
1641    pub(super) builder: CstBuilder,
1642}
1643impl CodeBlockStart3Node {
1644    /// Consume this node and return its builder
1645    pub fn into_builder(self) -> CstBuilder {
1646        self.builder
1647    }
1648}
1649impl From<CodeBlockStart3Node> for BuilderNodeId {
1650    fn from(node: CodeBlockStart3Node) -> Self {
1651        node.node_id
1652    }
1653}
1654///Branded type for CodeBlockStart4 non-terminal
1655#[derive(Debug, Clone)]
1656pub struct CodeBlockStart4Node {
1657    pub(super) node_id: BuilderNodeId,
1658    pub(super) builder: CstBuilder,
1659}
1660impl CodeBlockStart4Node {
1661    /// Consume this node and return its builder
1662    pub fn into_builder(self) -> CstBuilder {
1663        self.builder
1664    }
1665}
1666impl From<CodeBlockStart4Node> for BuilderNodeId {
1667    fn from(node: CodeBlockStart4Node) -> Self {
1668        node.node_id
1669    }
1670}
1671///Branded type for CodeBlockStart5 non-terminal
1672#[derive(Debug, Clone)]
1673pub struct CodeBlockStart5Node {
1674    pub(super) node_id: BuilderNodeId,
1675    pub(super) builder: CstBuilder,
1676}
1677impl CodeBlockStart5Node {
1678    /// Consume this node and return its builder
1679    pub fn into_builder(self) -> CstBuilder {
1680        self.builder
1681    }
1682}
1683impl From<CodeBlockStart5Node> for BuilderNodeId {
1684    fn from(node: CodeBlockStart5Node) -> Self {
1685        node.node_id
1686    }
1687}
1688///Branded type for CodeBlockStart6 non-terminal
1689#[derive(Debug, Clone)]
1690pub struct CodeBlockStart6Node {
1691    pub(super) node_id: BuilderNodeId,
1692    pub(super) builder: CstBuilder,
1693}
1694impl CodeBlockStart6Node {
1695    /// Consume this node and return its builder
1696    pub fn into_builder(self) -> CstBuilder {
1697        self.builder
1698    }
1699}
1700impl From<CodeBlockStart6Node> for BuilderNodeId {
1701    fn from(node: CodeBlockStart6Node) -> Self {
1702        node.node_id
1703    }
1704}
1705///Branded type for Comma non-terminal
1706#[derive(Debug, Clone)]
1707pub struct CommaNode {
1708    pub(super) node_id: BuilderNodeId,
1709    pub(super) builder: CstBuilder,
1710}
1711impl CommaNode {
1712    /// Consume this node and return its builder
1713    pub fn into_builder(self) -> CstBuilder {
1714        self.builder
1715    }
1716}
1717impl From<CommaNode> for BuilderNodeId {
1718    fn from(node: CommaNode) -> Self {
1719        node.node_id
1720    }
1721}
1722///Branded type for Continue non-terminal
1723#[derive(Debug, Clone)]
1724pub struct ContinueNode {
1725    pub(super) node_id: BuilderNodeId,
1726    pub(super) builder: CstBuilder,
1727}
1728impl ContinueNode {
1729    /// Consume this node and return its builder
1730    pub fn into_builder(self) -> CstBuilder {
1731        self.builder
1732    }
1733}
1734impl From<ContinueNode> for BuilderNodeId {
1735    fn from(node: ContinueNode) -> Self {
1736        node.node_id
1737    }
1738}
1739///Branded type for DelimCode non-terminal
1740#[derive(Debug, Clone)]
1741pub struct DelimCodeNode {
1742    pub(super) node_id: BuilderNodeId,
1743    pub(super) builder: CstBuilder,
1744}
1745impl DelimCodeNode {
1746    /// Consume this node and return its builder
1747    pub fn into_builder(self) -> CstBuilder {
1748        self.builder
1749    }
1750}
1751impl From<DelimCodeNode> for BuilderNodeId {
1752    fn from(node: DelimCodeNode) -> Self {
1753        node.node_id
1754    }
1755}
1756///Branded type for DelimCode1 non-terminal
1757#[derive(Debug, Clone)]
1758pub struct DelimCode1Node {
1759    pub(super) node_id: BuilderNodeId,
1760    pub(super) builder: CstBuilder,
1761}
1762impl DelimCode1Node {
1763    /// Consume this node and return its builder
1764    pub fn into_builder(self) -> CstBuilder {
1765        self.builder
1766    }
1767}
1768impl From<DelimCode1Node> for BuilderNodeId {
1769    fn from(node: DelimCode1Node) -> Self {
1770        node.node_id
1771    }
1772}
1773///Branded type for DelimCode1List non-terminal
1774#[derive(Debug, Clone)]
1775pub struct DelimCode1ListNode {
1776    pub(super) node_id: BuilderNodeId,
1777    pub(super) builder: CstBuilder,
1778}
1779impl DelimCode1ListNode {
1780    /// Consume this node and return its builder
1781    pub fn into_builder(self) -> CstBuilder {
1782        self.builder
1783    }
1784}
1785impl From<DelimCode1ListNode> for BuilderNodeId {
1786    fn from(node: DelimCode1ListNode) -> Self {
1787        node.node_id
1788    }
1789}
1790///Branded type for DelimCode1ListGroup non-terminal
1791#[derive(Debug, Clone)]
1792pub struct DelimCode1ListGroupNode {
1793    pub(super) node_id: BuilderNodeId,
1794    pub(super) builder: CstBuilder,
1795}
1796impl DelimCode1ListGroupNode {
1797    /// Consume this node and return its builder
1798    pub fn into_builder(self) -> CstBuilder {
1799        self.builder
1800    }
1801}
1802impl From<DelimCode1ListGroupNode> for BuilderNodeId {
1803    fn from(node: DelimCode1ListGroupNode) -> Self {
1804        node.node_id
1805    }
1806}
1807///Branded type for DelimCode2 non-terminal
1808#[derive(Debug, Clone)]
1809pub struct DelimCode2Node {
1810    pub(super) node_id: BuilderNodeId,
1811    pub(super) builder: CstBuilder,
1812}
1813impl DelimCode2Node {
1814    /// Consume this node and return its builder
1815    pub fn into_builder(self) -> CstBuilder {
1816        self.builder
1817    }
1818}
1819impl From<DelimCode2Node> for BuilderNodeId {
1820    fn from(node: DelimCode2Node) -> Self {
1821        node.node_id
1822    }
1823}
1824///Branded type for DelimCode2List non-terminal
1825#[derive(Debug, Clone)]
1826pub struct DelimCode2ListNode {
1827    pub(super) node_id: BuilderNodeId,
1828    pub(super) builder: CstBuilder,
1829}
1830impl DelimCode2ListNode {
1831    /// Consume this node and return its builder
1832    pub fn into_builder(self) -> CstBuilder {
1833        self.builder
1834    }
1835}
1836impl From<DelimCode2ListNode> for BuilderNodeId {
1837    fn from(node: DelimCode2ListNode) -> Self {
1838        node.node_id
1839    }
1840}
1841///Branded type for DelimCode2ListGroup non-terminal
1842#[derive(Debug, Clone)]
1843pub struct DelimCode2ListGroupNode {
1844    pub(super) node_id: BuilderNodeId,
1845    pub(super) builder: CstBuilder,
1846}
1847impl DelimCode2ListGroupNode {
1848    /// Consume this node and return its builder
1849    pub fn into_builder(self) -> CstBuilder {
1850        self.builder
1851    }
1852}
1853impl From<DelimCode2ListGroupNode> for BuilderNodeId {
1854    fn from(node: DelimCode2ListGroupNode) -> Self {
1855        node.node_id
1856    }
1857}
1858///Branded type for DelimCode3 non-terminal
1859#[derive(Debug, Clone)]
1860pub struct DelimCode3Node {
1861    pub(super) node_id: BuilderNodeId,
1862    pub(super) builder: CstBuilder,
1863}
1864impl DelimCode3Node {
1865    /// Consume this node and return its builder
1866    pub fn into_builder(self) -> CstBuilder {
1867        self.builder
1868    }
1869}
1870impl From<DelimCode3Node> for BuilderNodeId {
1871    fn from(node: DelimCode3Node) -> Self {
1872        node.node_id
1873    }
1874}
1875///Branded type for DelimCode3List non-terminal
1876#[derive(Debug, Clone)]
1877pub struct DelimCode3ListNode {
1878    pub(super) node_id: BuilderNodeId,
1879    pub(super) builder: CstBuilder,
1880}
1881impl DelimCode3ListNode {
1882    /// Consume this node and return its builder
1883    pub fn into_builder(self) -> CstBuilder {
1884        self.builder
1885    }
1886}
1887impl From<DelimCode3ListNode> for BuilderNodeId {
1888    fn from(node: DelimCode3ListNode) -> Self {
1889        node.node_id
1890    }
1891}
1892///Branded type for DelimCode3ListGroup non-terminal
1893#[derive(Debug, Clone)]
1894pub struct DelimCode3ListGroupNode {
1895    pub(super) node_id: BuilderNodeId,
1896    pub(super) builder: CstBuilder,
1897}
1898impl DelimCode3ListGroupNode {
1899    /// Consume this node and return its builder
1900    pub fn into_builder(self) -> CstBuilder {
1901        self.builder
1902    }
1903}
1904impl From<DelimCode3ListGroupNode> for BuilderNodeId {
1905    fn from(node: DelimCode3ListGroupNode) -> Self {
1906        node.node_id
1907    }
1908}
1909///Branded type for DelimCodeEnd1 non-terminal
1910#[derive(Debug, Clone)]
1911pub struct DelimCodeEnd1Node {
1912    pub(super) node_id: BuilderNodeId,
1913    pub(super) builder: CstBuilder,
1914}
1915impl DelimCodeEnd1Node {
1916    /// Consume this node and return its builder
1917    pub fn into_builder(self) -> CstBuilder {
1918        self.builder
1919    }
1920}
1921impl From<DelimCodeEnd1Node> for BuilderNodeId {
1922    fn from(node: DelimCodeEnd1Node) -> Self {
1923        node.node_id
1924    }
1925}
1926///Branded type for DelimCodeEnd2 non-terminal
1927#[derive(Debug, Clone)]
1928pub struct DelimCodeEnd2Node {
1929    pub(super) node_id: BuilderNodeId,
1930    pub(super) builder: CstBuilder,
1931}
1932impl DelimCodeEnd2Node {
1933    /// Consume this node and return its builder
1934    pub fn into_builder(self) -> CstBuilder {
1935        self.builder
1936    }
1937}
1938impl From<DelimCodeEnd2Node> for BuilderNodeId {
1939    fn from(node: DelimCodeEnd2Node) -> Self {
1940        node.node_id
1941    }
1942}
1943///Branded type for DelimCodeEnd3 non-terminal
1944#[derive(Debug, Clone)]
1945pub struct DelimCodeEnd3Node {
1946    pub(super) node_id: BuilderNodeId,
1947    pub(super) builder: CstBuilder,
1948}
1949impl DelimCodeEnd3Node {
1950    /// Consume this node and return its builder
1951    pub fn into_builder(self) -> CstBuilder {
1952        self.builder
1953    }
1954}
1955impl From<DelimCodeEnd3Node> for BuilderNodeId {
1956    fn from(node: DelimCodeEnd3Node) -> Self {
1957        node.node_id
1958    }
1959}
1960///Branded type for DelimCodeStart1 non-terminal
1961#[derive(Debug, Clone)]
1962pub struct DelimCodeStart1Node {
1963    pub(super) node_id: BuilderNodeId,
1964    pub(super) builder: CstBuilder,
1965}
1966impl DelimCodeStart1Node {
1967    /// Consume this node and return its builder
1968    pub fn into_builder(self) -> CstBuilder {
1969        self.builder
1970    }
1971}
1972impl From<DelimCodeStart1Node> for BuilderNodeId {
1973    fn from(node: DelimCodeStart1Node) -> Self {
1974        node.node_id
1975    }
1976}
1977///Branded type for DelimCodeStart2 non-terminal
1978#[derive(Debug, Clone)]
1979pub struct DelimCodeStart2Node {
1980    pub(super) node_id: BuilderNodeId,
1981    pub(super) builder: CstBuilder,
1982}
1983impl DelimCodeStart2Node {
1984    /// Consume this node and return its builder
1985    pub fn into_builder(self) -> CstBuilder {
1986        self.builder
1987    }
1988}
1989impl From<DelimCodeStart2Node> for BuilderNodeId {
1990    fn from(node: DelimCodeStart2Node) -> Self {
1991        node.node_id
1992    }
1993}
1994///Branded type for DelimCodeStart3 non-terminal
1995#[derive(Debug, Clone)]
1996pub struct DelimCodeStart3Node {
1997    pub(super) node_id: BuilderNodeId,
1998    pub(super) builder: CstBuilder,
1999}
2000impl DelimCodeStart3Node {
2001    /// Consume this node and return its builder
2002    pub fn into_builder(self) -> CstBuilder {
2003        self.builder
2004    }
2005}
2006impl From<DelimCodeStart3Node> for BuilderNodeId {
2007    fn from(node: DelimCodeStart3Node) -> Self {
2008        node.node_id
2009    }
2010}
2011///Branded type for Dot non-terminal
2012#[derive(Debug, Clone)]
2013pub struct DotNode {
2014    pub(super) node_id: BuilderNodeId,
2015    pub(super) builder: CstBuilder,
2016}
2017impl DotNode {
2018    /// Consume this node and return its builder
2019    pub fn into_builder(self) -> CstBuilder {
2020        self.builder
2021    }
2022}
2023impl From<DotNode> for BuilderNodeId {
2024    fn from(node: DotNode) -> Self {
2025        node.node_id
2026    }
2027}
2028///Branded type for End non-terminal
2029#[derive(Debug, Clone)]
2030pub struct EndNode {
2031    pub(super) node_id: BuilderNodeId,
2032    pub(super) builder: CstBuilder,
2033}
2034impl EndNode {
2035    /// Consume this node and return its builder
2036    pub fn into_builder(self) -> CstBuilder {
2037        self.builder
2038    }
2039}
2040impl From<EndNode> for BuilderNodeId {
2041    fn from(node: EndNode) -> Self {
2042        node.node_id
2043    }
2044}
2045///Branded type for Eure non-terminal
2046#[derive(Debug, Clone)]
2047pub struct EureNode {
2048    pub(super) node_id: BuilderNodeId,
2049    pub(super) builder: CstBuilder,
2050}
2051impl EureNode {
2052    /// Consume this node and return its builder
2053    pub fn into_builder(self) -> CstBuilder {
2054        self.builder
2055    }
2056}
2057impl From<EureNode> for BuilderNodeId {
2058    fn from(node: EureNode) -> Self {
2059        node.node_id
2060    }
2061}
2062///Branded type for EureBindings non-terminal
2063#[derive(Debug, Clone)]
2064pub struct EureBindingsNode {
2065    pub(super) node_id: BuilderNodeId,
2066    pub(super) builder: CstBuilder,
2067}
2068impl EureBindingsNode {
2069    /// Consume this node and return its builder
2070    pub fn into_builder(self) -> CstBuilder {
2071        self.builder
2072    }
2073}
2074impl From<EureBindingsNode> for BuilderNodeId {
2075    fn from(node: EureBindingsNode) -> Self {
2076        node.node_id
2077    }
2078}
2079///Branded type for EureSections non-terminal
2080#[derive(Debug, Clone)]
2081pub struct EureSectionsNode {
2082    pub(super) node_id: BuilderNodeId,
2083    pub(super) builder: CstBuilder,
2084}
2085impl EureSectionsNode {
2086    /// Consume this node and return its builder
2087    pub fn into_builder(self) -> CstBuilder {
2088        self.builder
2089    }
2090}
2091impl From<EureSectionsNode> for BuilderNodeId {
2092    fn from(node: EureSectionsNode) -> Self {
2093        node.node_id
2094    }
2095}
2096///Branded type for EureOpt non-terminal
2097#[derive(Debug, Clone)]
2098pub struct EureOptNode {
2099    pub(super) node_id: BuilderNodeId,
2100    pub(super) builder: CstBuilder,
2101}
2102impl EureOptNode {
2103    /// Consume this node and return its builder
2104    pub fn into_builder(self) -> CstBuilder {
2105        self.builder
2106    }
2107}
2108impl From<EureOptNode> for BuilderNodeId {
2109    fn from(node: EureOptNode) -> Self {
2110        node.node_id
2111    }
2112}
2113///Branded type for Ext non-terminal
2114#[derive(Debug, Clone)]
2115pub struct ExtNode {
2116    pub(super) node_id: BuilderNodeId,
2117    pub(super) builder: CstBuilder,
2118}
2119impl ExtNode {
2120    /// Consume this node and return its builder
2121    pub fn into_builder(self) -> CstBuilder {
2122        self.builder
2123    }
2124}
2125impl From<ExtNode> for BuilderNodeId {
2126    fn from(node: ExtNode) -> Self {
2127        node.node_id
2128    }
2129}
2130///Branded type for ExtensionNameSpace non-terminal
2131#[derive(Debug, Clone)]
2132pub struct ExtensionNameSpaceNode {
2133    pub(super) node_id: BuilderNodeId,
2134    pub(super) builder: CstBuilder,
2135}
2136impl ExtensionNameSpaceNode {
2137    /// Consume this node and return its builder
2138    pub fn into_builder(self) -> CstBuilder {
2139        self.builder
2140    }
2141}
2142impl From<ExtensionNameSpaceNode> for BuilderNodeId {
2143    fn from(node: ExtensionNameSpaceNode) -> Self {
2144        node.node_id
2145    }
2146}
2147///Branded type for False non-terminal
2148#[derive(Debug, Clone)]
2149pub struct FalseNode {
2150    pub(super) node_id: BuilderNodeId,
2151    pub(super) builder: CstBuilder,
2152}
2153impl FalseNode {
2154    /// Consume this node and return its builder
2155    pub fn into_builder(self) -> CstBuilder {
2156        self.builder
2157    }
2158}
2159impl From<FalseNode> for BuilderNodeId {
2160    fn from(node: FalseNode) -> Self {
2161        node.node_id
2162    }
2163}
2164///Branded type for Float non-terminal
2165#[derive(Debug, Clone)]
2166pub struct FloatNode {
2167    pub(super) node_id: BuilderNodeId,
2168    pub(super) builder: CstBuilder,
2169}
2170impl FloatNode {
2171    /// Consume this node and return its builder
2172    pub fn into_builder(self) -> CstBuilder {
2173        self.builder
2174    }
2175}
2176impl From<FloatNode> for BuilderNodeId {
2177    fn from(node: FloatNode) -> Self {
2178        node.node_id
2179    }
2180}
2181///Branded type for GrammarNewline non-terminal
2182#[derive(Debug, Clone)]
2183pub struct GrammarNewlineNode {
2184    pub(super) node_id: BuilderNodeId,
2185    pub(super) builder: CstBuilder,
2186}
2187impl GrammarNewlineNode {
2188    /// Consume this node and return its builder
2189    pub fn into_builder(self) -> CstBuilder {
2190        self.builder
2191    }
2192}
2193impl From<GrammarNewlineNode> for BuilderNodeId {
2194    fn from(node: GrammarNewlineNode) -> Self {
2195        node.node_id
2196    }
2197}
2198///Branded type for Hole non-terminal
2199#[derive(Debug, Clone)]
2200pub struct HoleNode {
2201    pub(super) node_id: BuilderNodeId,
2202    pub(super) builder: CstBuilder,
2203}
2204impl HoleNode {
2205    /// Consume this node and return its builder
2206    pub fn into_builder(self) -> CstBuilder {
2207        self.builder
2208    }
2209}
2210impl From<HoleNode> for BuilderNodeId {
2211    fn from(node: HoleNode) -> Self {
2212        node.node_id
2213    }
2214}
2215///Branded type for Ident non-terminal
2216#[derive(Debug, Clone)]
2217pub struct IdentNode {
2218    pub(super) node_id: BuilderNodeId,
2219    pub(super) builder: CstBuilder,
2220}
2221impl IdentNode {
2222    /// Consume this node and return its builder
2223    pub fn into_builder(self) -> CstBuilder {
2224        self.builder
2225    }
2226}
2227impl From<IdentNode> for BuilderNodeId {
2228    fn from(node: IdentNode) -> Self {
2229        node.node_id
2230    }
2231}
2232///Branded type for Inf non-terminal
2233#[derive(Debug, Clone)]
2234pub struct InfNode {
2235    pub(super) node_id: BuilderNodeId,
2236    pub(super) builder: CstBuilder,
2237}
2238impl InfNode {
2239    /// Consume this node and return its builder
2240    pub fn into_builder(self) -> CstBuilder {
2241        self.builder
2242    }
2243}
2244impl From<InfNode> for BuilderNodeId {
2245    fn from(node: InfNode) -> Self {
2246        node.node_id
2247    }
2248}
2249///Branded type for InlineCode non-terminal
2250#[derive(Debug, Clone)]
2251pub struct InlineCodeNode {
2252    pub(super) node_id: BuilderNodeId,
2253    pub(super) builder: CstBuilder,
2254}
2255impl InlineCodeNode {
2256    /// Consume this node and return its builder
2257    pub fn into_builder(self) -> CstBuilder {
2258        self.builder
2259    }
2260}
2261impl From<InlineCodeNode> for BuilderNodeId {
2262    fn from(node: InlineCodeNode) -> Self {
2263        node.node_id
2264    }
2265}
2266///Branded type for InlineCode1 non-terminal
2267#[derive(Debug, Clone)]
2268pub struct InlineCode1Node {
2269    pub(super) node_id: BuilderNodeId,
2270    pub(super) builder: CstBuilder,
2271}
2272impl InlineCode1Node {
2273    /// Consume this node and return its builder
2274    pub fn into_builder(self) -> CstBuilder {
2275        self.builder
2276    }
2277}
2278impl From<InlineCode1Node> for BuilderNodeId {
2279    fn from(node: InlineCode1Node) -> Self {
2280        node.node_id
2281    }
2282}
2283///Branded type for Integer non-terminal
2284#[derive(Debug, Clone)]
2285pub struct IntegerNode {
2286    pub(super) node_id: BuilderNodeId,
2287    pub(super) builder: CstBuilder,
2288}
2289impl IntegerNode {
2290    /// Consume this node and return its builder
2291    pub fn into_builder(self) -> CstBuilder {
2292        self.builder
2293    }
2294}
2295impl From<IntegerNode> for BuilderNodeId {
2296    fn from(node: IntegerNode) -> Self {
2297        node.node_id
2298    }
2299}
2300///Branded type for Key non-terminal
2301#[derive(Debug, Clone)]
2302pub struct KeyNode {
2303    pub(super) node_id: BuilderNodeId,
2304    pub(super) builder: CstBuilder,
2305}
2306impl KeyNode {
2307    /// Consume this node and return its builder
2308    pub fn into_builder(self) -> CstBuilder {
2309        self.builder
2310    }
2311}
2312impl From<KeyNode> for BuilderNodeId {
2313    fn from(node: KeyNode) -> Self {
2314        node.node_id
2315    }
2316}
2317///Branded type for KeyBase non-terminal
2318#[derive(Debug, Clone)]
2319pub struct KeyBaseNode {
2320    pub(super) node_id: BuilderNodeId,
2321    pub(super) builder: CstBuilder,
2322}
2323impl KeyBaseNode {
2324    /// Consume this node and return its builder
2325    pub fn into_builder(self) -> CstBuilder {
2326        self.builder
2327    }
2328}
2329impl From<KeyBaseNode> for BuilderNodeId {
2330    fn from(node: KeyBaseNode) -> Self {
2331        node.node_id
2332    }
2333}
2334///Branded type for KeyIdent non-terminal
2335#[derive(Debug, Clone)]
2336pub struct KeyIdentNode {
2337    pub(super) node_id: BuilderNodeId,
2338    pub(super) builder: CstBuilder,
2339}
2340impl KeyIdentNode {
2341    /// Consume this node and return its builder
2342    pub fn into_builder(self) -> CstBuilder {
2343        self.builder
2344    }
2345}
2346impl From<KeyIdentNode> for BuilderNodeId {
2347    fn from(node: KeyIdentNode) -> Self {
2348        node.node_id
2349    }
2350}
2351///Branded type for KeyOpt non-terminal
2352#[derive(Debug, Clone)]
2353pub struct KeyOptNode {
2354    pub(super) node_id: BuilderNodeId,
2355    pub(super) builder: CstBuilder,
2356}
2357impl KeyOptNode {
2358    /// Consume this node and return its builder
2359    pub fn into_builder(self) -> CstBuilder {
2360        self.builder
2361    }
2362}
2363impl From<KeyOptNode> for BuilderNodeId {
2364    fn from(node: KeyOptNode) -> Self {
2365        node.node_id
2366    }
2367}
2368///Branded type for KeyTuple non-terminal
2369#[derive(Debug, Clone)]
2370pub struct KeyTupleNode {
2371    pub(super) node_id: BuilderNodeId,
2372    pub(super) builder: CstBuilder,
2373}
2374impl KeyTupleNode {
2375    /// Consume this node and return its builder
2376    pub fn into_builder(self) -> CstBuilder {
2377        self.builder
2378    }
2379}
2380impl From<KeyTupleNode> for BuilderNodeId {
2381    fn from(node: KeyTupleNode) -> Self {
2382        node.node_id
2383    }
2384}
2385///Branded type for KeyTupleElements non-terminal
2386#[derive(Debug, Clone)]
2387pub struct KeyTupleElementsNode {
2388    pub(super) node_id: BuilderNodeId,
2389    pub(super) builder: CstBuilder,
2390}
2391impl KeyTupleElementsNode {
2392    /// Consume this node and return its builder
2393    pub fn into_builder(self) -> CstBuilder {
2394        self.builder
2395    }
2396}
2397impl From<KeyTupleElementsNode> for BuilderNodeId {
2398    fn from(node: KeyTupleElementsNode) -> Self {
2399        node.node_id
2400    }
2401}
2402///Branded type for KeyTupleElementsOpt non-terminal
2403#[derive(Debug, Clone)]
2404pub struct KeyTupleElementsOptNode {
2405    pub(super) node_id: BuilderNodeId,
2406    pub(super) builder: CstBuilder,
2407}
2408impl KeyTupleElementsOptNode {
2409    /// Consume this node and return its builder
2410    pub fn into_builder(self) -> CstBuilder {
2411        self.builder
2412    }
2413}
2414impl From<KeyTupleElementsOptNode> for BuilderNodeId {
2415    fn from(node: KeyTupleElementsOptNode) -> Self {
2416        node.node_id
2417    }
2418}
2419///Branded type for KeyTupleElementsTail non-terminal
2420#[derive(Debug, Clone)]
2421pub struct KeyTupleElementsTailNode {
2422    pub(super) node_id: BuilderNodeId,
2423    pub(super) builder: CstBuilder,
2424}
2425impl KeyTupleElementsTailNode {
2426    /// Consume this node and return its builder
2427    pub fn into_builder(self) -> CstBuilder {
2428        self.builder
2429    }
2430}
2431impl From<KeyTupleElementsTailNode> for BuilderNodeId {
2432    fn from(node: KeyTupleElementsTailNode) -> Self {
2433        node.node_id
2434    }
2435}
2436///Branded type for KeyTupleElementsTailOpt non-terminal
2437#[derive(Debug, Clone)]
2438pub struct KeyTupleElementsTailOptNode {
2439    pub(super) node_id: BuilderNodeId,
2440    pub(super) builder: CstBuilder,
2441}
2442impl KeyTupleElementsTailOptNode {
2443    /// Consume this node and return its builder
2444    pub fn into_builder(self) -> CstBuilder {
2445        self.builder
2446    }
2447}
2448impl From<KeyTupleElementsTailOptNode> for BuilderNodeId {
2449    fn from(node: KeyTupleElementsTailOptNode) -> Self {
2450        node.node_id
2451    }
2452}
2453///Branded type for KeyTupleOpt non-terminal
2454#[derive(Debug, Clone)]
2455pub struct KeyTupleOptNode {
2456    pub(super) node_id: BuilderNodeId,
2457    pub(super) builder: CstBuilder,
2458}
2459impl KeyTupleOptNode {
2460    /// Consume this node and return its builder
2461    pub fn into_builder(self) -> CstBuilder {
2462        self.builder
2463    }
2464}
2465impl From<KeyTupleOptNode> for BuilderNodeId {
2466    fn from(node: KeyTupleOptNode) -> Self {
2467        node.node_id
2468    }
2469}
2470///Branded type for KeyValue non-terminal
2471#[derive(Debug, Clone)]
2472pub struct KeyValueNode {
2473    pub(super) node_id: BuilderNodeId,
2474    pub(super) builder: CstBuilder,
2475}
2476impl KeyValueNode {
2477    /// Consume this node and return its builder
2478    pub fn into_builder(self) -> CstBuilder {
2479        self.builder
2480    }
2481}
2482impl From<KeyValueNode> for BuilderNodeId {
2483    fn from(node: KeyValueNode) -> Self {
2484        node.node_id
2485    }
2486}
2487///Branded type for Keys non-terminal
2488#[derive(Debug, Clone)]
2489pub struct KeysNode {
2490    pub(super) node_id: BuilderNodeId,
2491    pub(super) builder: CstBuilder,
2492}
2493impl KeysNode {
2494    /// Consume this node and return its builder
2495    pub fn into_builder(self) -> CstBuilder {
2496        self.builder
2497    }
2498}
2499impl From<KeysNode> for BuilderNodeId {
2500    fn from(node: KeysNode) -> Self {
2501        node.node_id
2502    }
2503}
2504///Branded type for KeysList non-terminal
2505#[derive(Debug, Clone)]
2506pub struct KeysListNode {
2507    pub(super) node_id: BuilderNodeId,
2508    pub(super) builder: CstBuilder,
2509}
2510impl KeysListNode {
2511    /// Consume this node and return its builder
2512    pub fn into_builder(self) -> CstBuilder {
2513        self.builder
2514    }
2515}
2516impl From<KeysListNode> for BuilderNodeId {
2517    fn from(node: KeysListNode) -> Self {
2518        node.node_id
2519    }
2520}
2521///Branded type for LParen non-terminal
2522#[derive(Debug, Clone)]
2523pub struct LParenNode {
2524    pub(super) node_id: BuilderNodeId,
2525    pub(super) builder: CstBuilder,
2526}
2527impl LParenNode {
2528    /// Consume this node and return its builder
2529    pub fn into_builder(self) -> CstBuilder {
2530        self.builder
2531    }
2532}
2533impl From<LParenNode> for BuilderNodeId {
2534    fn from(node: LParenNode) -> Self {
2535        node.node_id
2536    }
2537}
2538///Branded type for LitStr non-terminal
2539#[derive(Debug, Clone)]
2540pub struct LitStrNode {
2541    pub(super) node_id: BuilderNodeId,
2542    pub(super) builder: CstBuilder,
2543}
2544impl LitStrNode {
2545    /// Consume this node and return its builder
2546    pub fn into_builder(self) -> CstBuilder {
2547        self.builder
2548    }
2549}
2550impl From<LitStrNode> for BuilderNodeId {
2551    fn from(node: LitStrNode) -> Self {
2552        node.node_id
2553    }
2554}
2555///Branded type for LitStr1 non-terminal
2556#[derive(Debug, Clone)]
2557pub struct LitStr1Node {
2558    pub(super) node_id: BuilderNodeId,
2559    pub(super) builder: CstBuilder,
2560}
2561impl LitStr1Node {
2562    /// Consume this node and return its builder
2563    pub fn into_builder(self) -> CstBuilder {
2564        self.builder
2565    }
2566}
2567impl From<LitStr1Node> for BuilderNodeId {
2568    fn from(node: LitStr1Node) -> Self {
2569        node.node_id
2570    }
2571}
2572///Branded type for LitStr1End non-terminal
2573#[derive(Debug, Clone)]
2574pub struct LitStr1EndNode {
2575    pub(super) node_id: BuilderNodeId,
2576    pub(super) builder: CstBuilder,
2577}
2578impl LitStr1EndNode {
2579    /// Consume this node and return its builder
2580    pub fn into_builder(self) -> CstBuilder {
2581        self.builder
2582    }
2583}
2584impl From<LitStr1EndNode> for BuilderNodeId {
2585    fn from(node: LitStr1EndNode) -> Self {
2586        node.node_id
2587    }
2588}
2589///Branded type for LitStr1List non-terminal
2590#[derive(Debug, Clone)]
2591pub struct LitStr1ListNode {
2592    pub(super) node_id: BuilderNodeId,
2593    pub(super) builder: CstBuilder,
2594}
2595impl LitStr1ListNode {
2596    /// Consume this node and return its builder
2597    pub fn into_builder(self) -> CstBuilder {
2598        self.builder
2599    }
2600}
2601impl From<LitStr1ListNode> for BuilderNodeId {
2602    fn from(node: LitStr1ListNode) -> Self {
2603        node.node_id
2604    }
2605}
2606///Branded type for LitStr1ListGroup non-terminal
2607#[derive(Debug, Clone)]
2608pub struct LitStr1ListGroupNode {
2609    pub(super) node_id: BuilderNodeId,
2610    pub(super) builder: CstBuilder,
2611}
2612impl LitStr1ListGroupNode {
2613    /// Consume this node and return its builder
2614    pub fn into_builder(self) -> CstBuilder {
2615        self.builder
2616    }
2617}
2618impl From<LitStr1ListGroupNode> for BuilderNodeId {
2619    fn from(node: LitStr1ListGroupNode) -> Self {
2620        node.node_id
2621    }
2622}
2623///Branded type for LitStr1Start non-terminal
2624#[derive(Debug, Clone)]
2625pub struct LitStr1StartNode {
2626    pub(super) node_id: BuilderNodeId,
2627    pub(super) builder: CstBuilder,
2628}
2629impl LitStr1StartNode {
2630    /// Consume this node and return its builder
2631    pub fn into_builder(self) -> CstBuilder {
2632        self.builder
2633    }
2634}
2635impl From<LitStr1StartNode> for BuilderNodeId {
2636    fn from(node: LitStr1StartNode) -> Self {
2637        node.node_id
2638    }
2639}
2640///Branded type for LitStr2 non-terminal
2641#[derive(Debug, Clone)]
2642pub struct LitStr2Node {
2643    pub(super) node_id: BuilderNodeId,
2644    pub(super) builder: CstBuilder,
2645}
2646impl LitStr2Node {
2647    /// Consume this node and return its builder
2648    pub fn into_builder(self) -> CstBuilder {
2649        self.builder
2650    }
2651}
2652impl From<LitStr2Node> for BuilderNodeId {
2653    fn from(node: LitStr2Node) -> Self {
2654        node.node_id
2655    }
2656}
2657///Branded type for LitStr2End non-terminal
2658#[derive(Debug, Clone)]
2659pub struct LitStr2EndNode {
2660    pub(super) node_id: BuilderNodeId,
2661    pub(super) builder: CstBuilder,
2662}
2663impl LitStr2EndNode {
2664    /// Consume this node and return its builder
2665    pub fn into_builder(self) -> CstBuilder {
2666        self.builder
2667    }
2668}
2669impl From<LitStr2EndNode> for BuilderNodeId {
2670    fn from(node: LitStr2EndNode) -> Self {
2671        node.node_id
2672    }
2673}
2674///Branded type for LitStr2List non-terminal
2675#[derive(Debug, Clone)]
2676pub struct LitStr2ListNode {
2677    pub(super) node_id: BuilderNodeId,
2678    pub(super) builder: CstBuilder,
2679}
2680impl LitStr2ListNode {
2681    /// Consume this node and return its builder
2682    pub fn into_builder(self) -> CstBuilder {
2683        self.builder
2684    }
2685}
2686impl From<LitStr2ListNode> for BuilderNodeId {
2687    fn from(node: LitStr2ListNode) -> Self {
2688        node.node_id
2689    }
2690}
2691///Branded type for LitStr2ListGroup non-terminal
2692#[derive(Debug, Clone)]
2693pub struct LitStr2ListGroupNode {
2694    pub(super) node_id: BuilderNodeId,
2695    pub(super) builder: CstBuilder,
2696}
2697impl LitStr2ListGroupNode {
2698    /// Consume this node and return its builder
2699    pub fn into_builder(self) -> CstBuilder {
2700        self.builder
2701    }
2702}
2703impl From<LitStr2ListGroupNode> for BuilderNodeId {
2704    fn from(node: LitStr2ListGroupNode) -> Self {
2705        node.node_id
2706    }
2707}
2708///Branded type for LitStr2Start non-terminal
2709#[derive(Debug, Clone)]
2710pub struct LitStr2StartNode {
2711    pub(super) node_id: BuilderNodeId,
2712    pub(super) builder: CstBuilder,
2713}
2714impl LitStr2StartNode {
2715    /// Consume this node and return its builder
2716    pub fn into_builder(self) -> CstBuilder {
2717        self.builder
2718    }
2719}
2720impl From<LitStr2StartNode> for BuilderNodeId {
2721    fn from(node: LitStr2StartNode) -> Self {
2722        node.node_id
2723    }
2724}
2725///Branded type for LitStr3 non-terminal
2726#[derive(Debug, Clone)]
2727pub struct LitStr3Node {
2728    pub(super) node_id: BuilderNodeId,
2729    pub(super) builder: CstBuilder,
2730}
2731impl LitStr3Node {
2732    /// Consume this node and return its builder
2733    pub fn into_builder(self) -> CstBuilder {
2734        self.builder
2735    }
2736}
2737impl From<LitStr3Node> for BuilderNodeId {
2738    fn from(node: LitStr3Node) -> Self {
2739        node.node_id
2740    }
2741}
2742///Branded type for LitStr3End non-terminal
2743#[derive(Debug, Clone)]
2744pub struct LitStr3EndNode {
2745    pub(super) node_id: BuilderNodeId,
2746    pub(super) builder: CstBuilder,
2747}
2748impl LitStr3EndNode {
2749    /// Consume this node and return its builder
2750    pub fn into_builder(self) -> CstBuilder {
2751        self.builder
2752    }
2753}
2754impl From<LitStr3EndNode> for BuilderNodeId {
2755    fn from(node: LitStr3EndNode) -> Self {
2756        node.node_id
2757    }
2758}
2759///Branded type for LitStr3List non-terminal
2760#[derive(Debug, Clone)]
2761pub struct LitStr3ListNode {
2762    pub(super) node_id: BuilderNodeId,
2763    pub(super) builder: CstBuilder,
2764}
2765impl LitStr3ListNode {
2766    /// Consume this node and return its builder
2767    pub fn into_builder(self) -> CstBuilder {
2768        self.builder
2769    }
2770}
2771impl From<LitStr3ListNode> for BuilderNodeId {
2772    fn from(node: LitStr3ListNode) -> Self {
2773        node.node_id
2774    }
2775}
2776///Branded type for LitStr3ListGroup non-terminal
2777#[derive(Debug, Clone)]
2778pub struct LitStr3ListGroupNode {
2779    pub(super) node_id: BuilderNodeId,
2780    pub(super) builder: CstBuilder,
2781}
2782impl LitStr3ListGroupNode {
2783    /// Consume this node and return its builder
2784    pub fn into_builder(self) -> CstBuilder {
2785        self.builder
2786    }
2787}
2788impl From<LitStr3ListGroupNode> for BuilderNodeId {
2789    fn from(node: LitStr3ListGroupNode) -> Self {
2790        node.node_id
2791    }
2792}
2793///Branded type for LitStr3Start non-terminal
2794#[derive(Debug, Clone)]
2795pub struct LitStr3StartNode {
2796    pub(super) node_id: BuilderNodeId,
2797    pub(super) builder: CstBuilder,
2798}
2799impl LitStr3StartNode {
2800    /// Consume this node and return its builder
2801    pub fn into_builder(self) -> CstBuilder {
2802        self.builder
2803    }
2804}
2805impl From<LitStr3StartNode> for BuilderNodeId {
2806    fn from(node: LitStr3StartNode) -> Self {
2807        node.node_id
2808    }
2809}
2810///Branded type for MapBind non-terminal
2811#[derive(Debug, Clone)]
2812pub struct MapBindNode {
2813    pub(super) node_id: BuilderNodeId,
2814    pub(super) builder: CstBuilder,
2815}
2816impl MapBindNode {
2817    /// Consume this node and return its builder
2818    pub fn into_builder(self) -> CstBuilder {
2819        self.builder
2820    }
2821}
2822impl From<MapBindNode> for BuilderNodeId {
2823    fn from(node: MapBindNode) -> Self {
2824        node.node_id
2825    }
2826}
2827///Branded type for NaN non-terminal
2828#[derive(Debug, Clone)]
2829pub struct NaNNode {
2830    pub(super) node_id: BuilderNodeId,
2831    pub(super) builder: CstBuilder,
2832}
2833impl NaNNode {
2834    /// Consume this node and return its builder
2835    pub fn into_builder(self) -> CstBuilder {
2836        self.builder
2837    }
2838}
2839impl From<NaNNode> for BuilderNodeId {
2840    fn from(node: NaNNode) -> Self {
2841        node.node_id
2842    }
2843}
2844///Branded type for NoBacktick non-terminal
2845#[derive(Debug, Clone)]
2846pub struct NoBacktickNode {
2847    pub(super) node_id: BuilderNodeId,
2848    pub(super) builder: CstBuilder,
2849}
2850impl NoBacktickNode {
2851    /// Consume this node and return its builder
2852    pub fn into_builder(self) -> CstBuilder {
2853        self.builder
2854    }
2855}
2856impl From<NoBacktickNode> for BuilderNodeId {
2857    fn from(node: NoBacktickNode) -> Self {
2858        node.node_id
2859    }
2860}
2861///Branded type for NoSQuote non-terminal
2862#[derive(Debug, Clone)]
2863pub struct NoSQuoteNode {
2864    pub(super) node_id: BuilderNodeId,
2865    pub(super) builder: CstBuilder,
2866}
2867impl NoSQuoteNode {
2868    /// Consume this node and return its builder
2869    pub fn into_builder(self) -> CstBuilder {
2870        self.builder
2871    }
2872}
2873impl From<NoSQuoteNode> for BuilderNodeId {
2874    fn from(node: NoSQuoteNode) -> Self {
2875        node.node_id
2876    }
2877}
2878///Branded type for Null non-terminal
2879#[derive(Debug, Clone)]
2880pub struct NullNode {
2881    pub(super) node_id: BuilderNodeId,
2882    pub(super) builder: CstBuilder,
2883}
2884impl NullNode {
2885    /// Consume this node and return its builder
2886    pub fn into_builder(self) -> CstBuilder {
2887        self.builder
2888    }
2889}
2890impl From<NullNode> for BuilderNodeId {
2891    fn from(node: NullNode) -> Self {
2892        node.node_id
2893    }
2894}
2895///Branded type for Number non-terminal
2896#[derive(Debug, Clone)]
2897pub struct NumberNode {
2898    pub(super) node_id: BuilderNodeId,
2899    pub(super) builder: CstBuilder,
2900}
2901impl NumberNode {
2902    /// Consume this node and return its builder
2903    pub fn into_builder(self) -> CstBuilder {
2904        self.builder
2905    }
2906}
2907impl From<NumberNode> for BuilderNodeId {
2908    fn from(node: NumberNode) -> Self {
2909        node.node_id
2910    }
2911}
2912///Branded type for Object non-terminal
2913#[derive(Debug, Clone)]
2914pub struct ObjectNode {
2915    pub(super) node_id: BuilderNodeId,
2916    pub(super) builder: CstBuilder,
2917}
2918impl ObjectNode {
2919    /// Consume this node and return its builder
2920    pub fn into_builder(self) -> CstBuilder {
2921        self.builder
2922    }
2923}
2924impl From<ObjectNode> for BuilderNodeId {
2925    fn from(node: ObjectNode) -> Self {
2926        node.node_id
2927    }
2928}
2929///Branded type for ObjectList non-terminal
2930#[derive(Debug, Clone)]
2931pub struct ObjectListNode {
2932    pub(super) node_id: BuilderNodeId,
2933    pub(super) builder: CstBuilder,
2934}
2935impl ObjectListNode {
2936    /// Consume this node and return its builder
2937    pub fn into_builder(self) -> CstBuilder {
2938        self.builder
2939    }
2940}
2941impl From<ObjectListNode> for BuilderNodeId {
2942    fn from(node: ObjectListNode) -> Self {
2943        node.node_id
2944    }
2945}
2946///Branded type for ObjectOpt non-terminal
2947#[derive(Debug, Clone)]
2948pub struct ObjectOptNode {
2949    pub(super) node_id: BuilderNodeId,
2950    pub(super) builder: CstBuilder,
2951}
2952impl ObjectOptNode {
2953    /// Consume this node and return its builder
2954    pub fn into_builder(self) -> CstBuilder {
2955        self.builder
2956    }
2957}
2958impl From<ObjectOptNode> for BuilderNodeId {
2959    fn from(node: ObjectOptNode) -> Self {
2960        node.node_id
2961    }
2962}
2963///Branded type for ObjectOpt0 non-terminal
2964#[derive(Debug, Clone)]
2965pub struct ObjectOpt0Node {
2966    pub(super) node_id: BuilderNodeId,
2967    pub(super) builder: CstBuilder,
2968}
2969impl ObjectOpt0Node {
2970    /// Consume this node and return its builder
2971    pub fn into_builder(self) -> CstBuilder {
2972        self.builder
2973    }
2974}
2975impl From<ObjectOpt0Node> for BuilderNodeId {
2976    fn from(node: ObjectOpt0Node) -> Self {
2977        node.node_id
2978    }
2979}
2980///Branded type for ObjectOpt1 non-terminal
2981#[derive(Debug, Clone)]
2982pub struct ObjectOpt1Node {
2983    pub(super) node_id: BuilderNodeId,
2984    pub(super) builder: CstBuilder,
2985}
2986impl ObjectOpt1Node {
2987    /// Consume this node and return its builder
2988    pub fn into_builder(self) -> CstBuilder {
2989        self.builder
2990    }
2991}
2992impl From<ObjectOpt1Node> for BuilderNodeId {
2993    fn from(node: ObjectOpt1Node) -> Self {
2994        node.node_id
2995    }
2996}
2997///Branded type for RParen non-terminal
2998#[derive(Debug, Clone)]
2999pub struct RParenNode {
3000    pub(super) node_id: BuilderNodeId,
3001    pub(super) builder: CstBuilder,
3002}
3003impl RParenNode {
3004    /// Consume this node and return its builder
3005    pub fn into_builder(self) -> CstBuilder {
3006        self.builder
3007    }
3008}
3009impl From<RParenNode> for BuilderNodeId {
3010    fn from(node: RParenNode) -> Self {
3011        node.node_id
3012    }
3013}
3014///Branded type for RootBinding non-terminal
3015#[derive(Debug, Clone)]
3016pub struct RootBindingNode {
3017    pub(super) node_id: BuilderNodeId,
3018    pub(super) builder: CstBuilder,
3019}
3020impl RootBindingNode {
3021    /// Consume this node and return its builder
3022    pub fn into_builder(self) -> CstBuilder {
3023        self.builder
3024    }
3025}
3026impl From<RootBindingNode> for BuilderNodeId {
3027    fn from(node: RootBindingNode) -> Self {
3028        node.node_id
3029    }
3030}
3031///Branded type for SQuote non-terminal
3032#[derive(Debug, Clone)]
3033pub struct SQuoteNode {
3034    pub(super) node_id: BuilderNodeId,
3035    pub(super) builder: CstBuilder,
3036}
3037impl SQuoteNode {
3038    /// Consume this node and return its builder
3039    pub fn into_builder(self) -> CstBuilder {
3040        self.builder
3041    }
3042}
3043impl From<SQuoteNode> for BuilderNodeId {
3044    fn from(node: SQuoteNode) -> Self {
3045        node.node_id
3046    }
3047}
3048///Branded type for Section non-terminal
3049#[derive(Debug, Clone)]
3050pub struct SectionNode {
3051    pub(super) node_id: BuilderNodeId,
3052    pub(super) builder: CstBuilder,
3053}
3054impl SectionNode {
3055    /// Consume this node and return its builder
3056    pub fn into_builder(self) -> CstBuilder {
3057        self.builder
3058    }
3059}
3060impl From<SectionNode> for BuilderNodeId {
3061    fn from(node: SectionNode) -> Self {
3062        node.node_id
3063    }
3064}
3065///Branded type for SectionBinding non-terminal
3066#[derive(Debug, Clone)]
3067pub struct SectionBindingNode {
3068    pub(super) node_id: BuilderNodeId,
3069    pub(super) builder: CstBuilder,
3070}
3071impl SectionBindingNode {
3072    /// Consume this node and return its builder
3073    pub fn into_builder(self) -> CstBuilder {
3074        self.builder
3075    }
3076}
3077impl From<SectionBindingNode> for BuilderNodeId {
3078    fn from(node: SectionBindingNode) -> Self {
3079        node.node_id
3080    }
3081}
3082///Branded type for SectionBody non-terminal
3083#[derive(Debug, Clone)]
3084pub struct SectionBodyNode {
3085    pub(super) node_id: BuilderNodeId,
3086    pub(super) builder: CstBuilder,
3087}
3088impl SectionBodyNode {
3089    /// Consume this node and return its builder
3090    pub fn into_builder(self) -> CstBuilder {
3091        self.builder
3092    }
3093}
3094impl From<SectionBodyNode> for BuilderNodeId {
3095    fn from(node: SectionBodyNode) -> Self {
3096        node.node_id
3097    }
3098}
3099///Branded type for SectionBodyList non-terminal
3100#[derive(Debug, Clone)]
3101pub struct SectionBodyListNode {
3102    pub(super) node_id: BuilderNodeId,
3103    pub(super) builder: CstBuilder,
3104}
3105impl SectionBodyListNode {
3106    /// Consume this node and return its builder
3107    pub fn into_builder(self) -> CstBuilder {
3108        self.builder
3109    }
3110}
3111impl From<SectionBodyListNode> for BuilderNodeId {
3112    fn from(node: SectionBodyListNode) -> Self {
3113        node.node_id
3114    }
3115}
3116///Branded type for SectionBodyOpt non-terminal
3117#[derive(Debug, Clone)]
3118pub struct SectionBodyOptNode {
3119    pub(super) node_id: BuilderNodeId,
3120    pub(super) builder: CstBuilder,
3121}
3122impl SectionBodyOptNode {
3123    /// Consume this node and return its builder
3124    pub fn into_builder(self) -> CstBuilder {
3125        self.builder
3126    }
3127}
3128impl From<SectionBodyOptNode> for BuilderNodeId {
3129    fn from(node: SectionBodyOptNode) -> Self {
3130        node.node_id
3131    }
3132}
3133///Branded type for Str non-terminal
3134#[derive(Debug, Clone)]
3135pub struct StrNode {
3136    pub(super) node_id: BuilderNodeId,
3137    pub(super) builder: CstBuilder,
3138}
3139impl StrNode {
3140    /// Consume this node and return its builder
3141    pub fn into_builder(self) -> CstBuilder {
3142        self.builder
3143    }
3144}
3145impl From<StrNode> for BuilderNodeId {
3146    fn from(node: StrNode) -> Self {
3147        node.node_id
3148    }
3149}
3150///Branded type for String non-terminal
3151#[derive(Debug, Clone)]
3152pub struct StringNode {
3153    pub(super) node_id: BuilderNodeId,
3154    pub(super) builder: CstBuilder,
3155}
3156impl StringNode {
3157    /// Consume this node and return its builder
3158    pub fn into_builder(self) -> CstBuilder {
3159        self.builder
3160    }
3161}
3162impl From<StringNode> for BuilderNodeId {
3163    fn from(node: StringNode) -> Self {
3164        node.node_id
3165    }
3166}
3167///Branded type for Strings non-terminal
3168#[derive(Debug, Clone)]
3169pub struct StringsNode {
3170    pub(super) node_id: BuilderNodeId,
3171    pub(super) builder: CstBuilder,
3172}
3173impl StringsNode {
3174    /// Consume this node and return its builder
3175    pub fn into_builder(self) -> CstBuilder {
3176        self.builder
3177    }
3178}
3179impl From<StringsNode> for BuilderNodeId {
3180    fn from(node: StringsNode) -> Self {
3181        node.node_id
3182    }
3183}
3184///Branded type for StringsList non-terminal
3185#[derive(Debug, Clone)]
3186pub struct StringsListNode {
3187    pub(super) node_id: BuilderNodeId,
3188    pub(super) builder: CstBuilder,
3189}
3190impl StringsListNode {
3191    /// Consume this node and return its builder
3192    pub fn into_builder(self) -> CstBuilder {
3193        self.builder
3194    }
3195}
3196impl From<StringsListNode> for BuilderNodeId {
3197    fn from(node: StringsListNode) -> Self {
3198        node.node_id
3199    }
3200}
3201///Branded type for Text non-terminal
3202#[derive(Debug, Clone)]
3203pub struct TextNode {
3204    pub(super) node_id: BuilderNodeId,
3205    pub(super) builder: CstBuilder,
3206}
3207impl TextNode {
3208    /// Consume this node and return its builder
3209    pub fn into_builder(self) -> CstBuilder {
3210        self.builder
3211    }
3212}
3213impl From<TextNode> for BuilderNodeId {
3214    fn from(node: TextNode) -> Self {
3215        node.node_id
3216    }
3217}
3218///Branded type for TextBinding non-terminal
3219#[derive(Debug, Clone)]
3220pub struct TextBindingNode {
3221    pub(super) node_id: BuilderNodeId,
3222    pub(super) builder: CstBuilder,
3223}
3224impl TextBindingNode {
3225    /// Consume this node and return its builder
3226    pub fn into_builder(self) -> CstBuilder {
3227        self.builder
3228    }
3229}
3230impl From<TextBindingNode> for BuilderNodeId {
3231    fn from(node: TextBindingNode) -> Self {
3232        node.node_id
3233    }
3234}
3235///Branded type for TextBindingOpt non-terminal
3236#[derive(Debug, Clone)]
3237pub struct TextBindingOptNode {
3238    pub(super) node_id: BuilderNodeId,
3239    pub(super) builder: CstBuilder,
3240}
3241impl TextBindingOptNode {
3242    /// Consume this node and return its builder
3243    pub fn into_builder(self) -> CstBuilder {
3244        self.builder
3245    }
3246}
3247impl From<TextBindingOptNode> for BuilderNodeId {
3248    fn from(node: TextBindingOptNode) -> Self {
3249        node.node_id
3250    }
3251}
3252///Branded type for TextBindingOpt0 non-terminal
3253#[derive(Debug, Clone)]
3254pub struct TextBindingOpt0Node {
3255    pub(super) node_id: BuilderNodeId,
3256    pub(super) builder: CstBuilder,
3257}
3258impl TextBindingOpt0Node {
3259    /// Consume this node and return its builder
3260    pub fn into_builder(self) -> CstBuilder {
3261        self.builder
3262    }
3263}
3264impl From<TextBindingOpt0Node> for BuilderNodeId {
3265    fn from(node: TextBindingOpt0Node) -> Self {
3266        node.node_id
3267    }
3268}
3269///Branded type for TextBindingOpt1 non-terminal
3270#[derive(Debug, Clone)]
3271pub struct TextBindingOpt1Node {
3272    pub(super) node_id: BuilderNodeId,
3273    pub(super) builder: CstBuilder,
3274}
3275impl TextBindingOpt1Node {
3276    /// Consume this node and return its builder
3277    pub fn into_builder(self) -> CstBuilder {
3278        self.builder
3279    }
3280}
3281impl From<TextBindingOpt1Node> for BuilderNodeId {
3282    fn from(node: TextBindingOpt1Node) -> Self {
3283        node.node_id
3284    }
3285}
3286///Branded type for TextStart non-terminal
3287#[derive(Debug, Clone)]
3288pub struct TextStartNode {
3289    pub(super) node_id: BuilderNodeId,
3290    pub(super) builder: CstBuilder,
3291}
3292impl TextStartNode {
3293    /// Consume this node and return its builder
3294    pub fn into_builder(self) -> CstBuilder {
3295        self.builder
3296    }
3297}
3298impl From<TextStartNode> for BuilderNodeId {
3299    fn from(node: TextStartNode) -> Self {
3300        node.node_id
3301    }
3302}
3303///Branded type for True non-terminal
3304#[derive(Debug, Clone)]
3305pub struct TrueNode {
3306    pub(super) node_id: BuilderNodeId,
3307    pub(super) builder: CstBuilder,
3308}
3309impl TrueNode {
3310    /// Consume this node and return its builder
3311    pub fn into_builder(self) -> CstBuilder {
3312        self.builder
3313    }
3314}
3315impl From<TrueNode> for BuilderNodeId {
3316    fn from(node: TrueNode) -> Self {
3317        node.node_id
3318    }
3319}
3320///Branded type for Tuple non-terminal
3321#[derive(Debug, Clone)]
3322pub struct TupleNode {
3323    pub(super) node_id: BuilderNodeId,
3324    pub(super) builder: CstBuilder,
3325}
3326impl TupleNode {
3327    /// Consume this node and return its builder
3328    pub fn into_builder(self) -> CstBuilder {
3329        self.builder
3330    }
3331}
3332impl From<TupleNode> for BuilderNodeId {
3333    fn from(node: TupleNode) -> Self {
3334        node.node_id
3335    }
3336}
3337///Branded type for TupleElements non-terminal
3338#[derive(Debug, Clone)]
3339pub struct TupleElementsNode {
3340    pub(super) node_id: BuilderNodeId,
3341    pub(super) builder: CstBuilder,
3342}
3343impl TupleElementsNode {
3344    /// Consume this node and return its builder
3345    pub fn into_builder(self) -> CstBuilder {
3346        self.builder
3347    }
3348}
3349impl From<TupleElementsNode> for BuilderNodeId {
3350    fn from(node: TupleElementsNode) -> Self {
3351        node.node_id
3352    }
3353}
3354///Branded type for TupleElementsOpt non-terminal
3355#[derive(Debug, Clone)]
3356pub struct TupleElementsOptNode {
3357    pub(super) node_id: BuilderNodeId,
3358    pub(super) builder: CstBuilder,
3359}
3360impl TupleElementsOptNode {
3361    /// Consume this node and return its builder
3362    pub fn into_builder(self) -> CstBuilder {
3363        self.builder
3364    }
3365}
3366impl From<TupleElementsOptNode> for BuilderNodeId {
3367    fn from(node: TupleElementsOptNode) -> Self {
3368        node.node_id
3369    }
3370}
3371///Branded type for TupleElementsTail non-terminal
3372#[derive(Debug, Clone)]
3373pub struct TupleElementsTailNode {
3374    pub(super) node_id: BuilderNodeId,
3375    pub(super) builder: CstBuilder,
3376}
3377impl TupleElementsTailNode {
3378    /// Consume this node and return its builder
3379    pub fn into_builder(self) -> CstBuilder {
3380        self.builder
3381    }
3382}
3383impl From<TupleElementsTailNode> for BuilderNodeId {
3384    fn from(node: TupleElementsTailNode) -> Self {
3385        node.node_id
3386    }
3387}
3388///Branded type for TupleElementsTailOpt non-terminal
3389#[derive(Debug, Clone)]
3390pub struct TupleElementsTailOptNode {
3391    pub(super) node_id: BuilderNodeId,
3392    pub(super) builder: CstBuilder,
3393}
3394impl TupleElementsTailOptNode {
3395    /// Consume this node and return its builder
3396    pub fn into_builder(self) -> CstBuilder {
3397        self.builder
3398    }
3399}
3400impl From<TupleElementsTailOptNode> for BuilderNodeId {
3401    fn from(node: TupleElementsTailOptNode) -> Self {
3402        node.node_id
3403    }
3404}
3405///Branded type for TupleIndex non-terminal
3406#[derive(Debug, Clone)]
3407pub struct TupleIndexNode {
3408    pub(super) node_id: BuilderNodeId,
3409    pub(super) builder: CstBuilder,
3410}
3411impl TupleIndexNode {
3412    /// Consume this node and return its builder
3413    pub fn into_builder(self) -> CstBuilder {
3414        self.builder
3415    }
3416}
3417impl From<TupleIndexNode> for BuilderNodeId {
3418    fn from(node: TupleIndexNode) -> Self {
3419        node.node_id
3420    }
3421}
3422///Branded type for TupleOpt non-terminal
3423#[derive(Debug, Clone)]
3424pub struct TupleOptNode {
3425    pub(super) node_id: BuilderNodeId,
3426    pub(super) builder: CstBuilder,
3427}
3428impl TupleOptNode {
3429    /// Consume this node and return its builder
3430    pub fn into_builder(self) -> CstBuilder {
3431        self.builder
3432    }
3433}
3434impl From<TupleOptNode> for BuilderNodeId {
3435    fn from(node: TupleOptNode) -> Self {
3436        node.node_id
3437    }
3438}
3439///Branded type for Value non-terminal
3440#[derive(Debug, Clone)]
3441pub struct ValueNode {
3442    pub(super) node_id: BuilderNodeId,
3443    pub(super) builder: CstBuilder,
3444}
3445impl ValueNode {
3446    /// Consume this node and return its builder
3447    pub fn into_builder(self) -> CstBuilder {
3448        self.builder
3449    }
3450}
3451impl From<ValueNode> for BuilderNodeId {
3452    fn from(node: ValueNode) -> Self {
3453        node.node_id
3454    }
3455}
3456///Branded type for ValueBinding non-terminal
3457#[derive(Debug, Clone)]
3458pub struct ValueBindingNode {
3459    pub(super) node_id: BuilderNodeId,
3460    pub(super) builder: CstBuilder,
3461}
3462impl ValueBindingNode {
3463    /// Consume this node and return its builder
3464    pub fn into_builder(self) -> CstBuilder {
3465        self.builder
3466    }
3467}
3468impl From<ValueBindingNode> for BuilderNodeId {
3469    fn from(node: ValueBindingNode) -> Self {
3470        node.node_id
3471    }
3472}
3473///Branded type for Ws non-terminal
3474#[derive(Debug, Clone)]
3475pub struct WsNode {
3476    pub(super) node_id: BuilderNodeId,
3477    pub(super) builder: CstBuilder,
3478}
3479impl WsNode {
3480    /// Consume this node and return its builder
3481    pub fn into_builder(self) -> CstBuilder {
3482        self.builder
3483    }
3484}
3485impl From<WsNode> for BuilderNodeId {
3486    fn from(node: WsNode) -> Self {
3487        node.node_id
3488    }
3489}
3490///Branded type for Root non-terminal
3491#[derive(Debug, Clone)]
3492pub struct RootNode {
3493    pub(super) node_id: BuilderNodeId,
3494    pub(super) builder: CstBuilder,
3495}
3496impl RootNode {
3497    /// Consume this node and return its builder
3498    pub fn into_builder(self) -> CstBuilder {
3499        self.builder
3500    }
3501}
3502impl From<RootNode> for BuilderNodeId {
3503    fn from(node: RootNode) -> Self {
3504        node.node_id
3505    }
3506}
3507#[derive(bon::Builder)]
3508pub struct ArrayConstructor {
3509    array_begin: ArrayBeginNode,
3510    array_opt: ArrayOptNode,
3511    array_end: ArrayEndNode,
3512}
3513impl ArrayConstructor {
3514    pub fn build(self) -> ArrayNode {
3515        let mut builder = CstBuilder::new();
3516        let array_begin = builder.embed(self.array_begin.builder);
3517        let array_opt = builder.embed(self.array_opt.builder);
3518        let array_end = builder.embed(self.array_end.builder);
3519        let node_id = builder.non_terminal(
3520            NonTerminalKind::Array,
3521            vec![array_begin, array_opt, array_end],
3522        );
3523        ArrayNode { node_id, builder }
3524    }
3525}
3526#[derive(bon::Builder)]
3527pub struct ArrayBeginConstructor {
3528    l_bracket: LBracketToken,
3529}
3530impl ArrayBeginConstructor {
3531    pub fn build(self) -> ArrayBeginNode {
3532        let mut builder = CstBuilder::new();
3533        let l_bracket = builder.embed(self.l_bracket.builder);
3534        let node_id = builder.non_terminal(NonTerminalKind::ArrayBegin, vec![l_bracket]);
3535        ArrayBeginNode { node_id, builder }
3536    }
3537}
3538#[derive(bon::Builder)]
3539pub struct ArrayElementsConstructor {
3540    value: ValueNode,
3541    array_elements_opt: ArrayElementsOptNode,
3542}
3543impl ArrayElementsConstructor {
3544    pub fn build(self) -> ArrayElementsNode {
3545        let mut builder = CstBuilder::new();
3546        let value = builder.embed(self.value.builder);
3547        let array_elements_opt = builder.embed(self.array_elements_opt.builder);
3548        let node_id = builder.non_terminal(
3549            NonTerminalKind::ArrayElements,
3550            vec![value, array_elements_opt],
3551        );
3552        ArrayElementsNode { node_id, builder }
3553    }
3554}
3555#[derive(bon::Builder)]
3556pub struct ArrayElementsOptConstructor {
3557    array_elements_tail: Option<ArrayElementsTailNode>,
3558}
3559impl ArrayElementsOptConstructor {
3560    pub fn build(self) -> ArrayElementsOptNode {
3561        let mut builder = CstBuilder::new();
3562        let children = if let Some(child) = self.array_elements_tail {
3563            vec![builder.embed(child.builder)]
3564        } else {
3565            Vec::<BuilderNodeId>::new()
3566        };
3567        let node_id = builder.non_terminal(NonTerminalKind::ArrayElementsOpt, children);
3568        ArrayElementsOptNode { node_id, builder }
3569    }
3570}
3571#[derive(bon::Builder)]
3572pub struct ArrayElementsTailConstructor {
3573    comma: CommaNode,
3574    array_elements_tail_opt: ArrayElementsTailOptNode,
3575}
3576impl ArrayElementsTailConstructor {
3577    pub fn build(self) -> ArrayElementsTailNode {
3578        let mut builder = CstBuilder::new();
3579        let comma = builder.embed(self.comma.builder);
3580        let array_elements_tail_opt = builder.embed(self.array_elements_tail_opt.builder);
3581        let node_id = builder.non_terminal(
3582            NonTerminalKind::ArrayElementsTail,
3583            vec![comma, array_elements_tail_opt],
3584        );
3585        ArrayElementsTailNode { node_id, builder }
3586    }
3587}
3588#[derive(bon::Builder)]
3589pub struct ArrayElementsTailOptConstructor {
3590    array_elements: Option<ArrayElementsNode>,
3591}
3592impl ArrayElementsTailOptConstructor {
3593    pub fn build(self) -> ArrayElementsTailOptNode {
3594        let mut builder = CstBuilder::new();
3595        let children = if let Some(child) = self.array_elements {
3596            vec![builder.embed(child.builder)]
3597        } else {
3598            Vec::<BuilderNodeId>::new()
3599        };
3600        let node_id = builder.non_terminal(NonTerminalKind::ArrayElementsTailOpt, children);
3601        ArrayElementsTailOptNode { node_id, builder }
3602    }
3603}
3604#[derive(bon::Builder)]
3605pub struct ArrayEndConstructor {
3606    r_bracket: RBracketToken,
3607}
3608impl ArrayEndConstructor {
3609    pub fn build(self) -> ArrayEndNode {
3610        let mut builder = CstBuilder::new();
3611        let r_bracket = builder.embed(self.r_bracket.builder);
3612        let node_id = builder.non_terminal(NonTerminalKind::ArrayEnd, vec![r_bracket]);
3613        ArrayEndNode { node_id, builder }
3614    }
3615}
3616#[derive(bon::Builder)]
3617pub struct ArrayMarkerConstructor {
3618    array_begin: ArrayBeginNode,
3619    array_marker_opt: ArrayMarkerOptNode,
3620    array_end: ArrayEndNode,
3621}
3622impl ArrayMarkerConstructor {
3623    pub fn build(self) -> ArrayMarkerNode {
3624        let mut builder = CstBuilder::new();
3625        let array_begin = builder.embed(self.array_begin.builder);
3626        let array_marker_opt = builder.embed(self.array_marker_opt.builder);
3627        let array_end = builder.embed(self.array_end.builder);
3628        let node_id = builder.non_terminal(
3629            NonTerminalKind::ArrayMarker,
3630            vec![array_begin, array_marker_opt, array_end],
3631        );
3632        ArrayMarkerNode { node_id, builder }
3633    }
3634}
3635#[derive(bon::Builder)]
3636pub struct ArrayMarkerOptConstructor {
3637    integer: Option<IntegerNode>,
3638}
3639impl ArrayMarkerOptConstructor {
3640    pub fn build(self) -> ArrayMarkerOptNode {
3641        let mut builder = CstBuilder::new();
3642        let children = if let Some(child) = self.integer {
3643            vec![builder.embed(child.builder)]
3644        } else {
3645            Vec::<BuilderNodeId>::new()
3646        };
3647        let node_id = builder.non_terminal(NonTerminalKind::ArrayMarkerOpt, children);
3648        ArrayMarkerOptNode { node_id, builder }
3649    }
3650}
3651#[derive(bon::Builder)]
3652pub struct ArrayOptConstructor {
3653    array_elements: Option<ArrayElementsNode>,
3654}
3655impl ArrayOptConstructor {
3656    pub fn build(self) -> ArrayOptNode {
3657        let mut builder = CstBuilder::new();
3658        let children = if let Some(child) = self.array_elements {
3659            vec![builder.embed(child.builder)]
3660        } else {
3661            Vec::<BuilderNodeId>::new()
3662        };
3663        let node_id = builder.non_terminal(NonTerminalKind::ArrayOpt, children);
3664        ArrayOptNode { node_id, builder }
3665    }
3666}
3667#[derive(bon::Builder)]
3668pub struct AtConstructor {
3669    at: AtToken,
3670}
3671impl AtConstructor {
3672    pub fn build(self) -> AtNode {
3673        let mut builder = CstBuilder::new();
3674        let at = builder.embed(self.at.builder);
3675        let node_id = builder.non_terminal(NonTerminalKind::At, vec![at]);
3676        AtNode { node_id, builder }
3677    }
3678}
3679#[derive(bon::Builder)]
3680pub struct Backtick2Constructor {
3681    backtick_2: Backtick2Token,
3682}
3683impl Backtick2Constructor {
3684    pub fn build(self) -> Backtick2Node {
3685        let mut builder = CstBuilder::new();
3686        let backtick_2 = builder.embed(self.backtick_2.builder);
3687        let node_id = builder.non_terminal(NonTerminalKind::Backtick2, vec![backtick_2]);
3688        Backtick2Node { node_id, builder }
3689    }
3690}
3691#[derive(bon::Builder)]
3692pub struct Backtick3Constructor {
3693    backtick_3: Backtick3Token,
3694}
3695impl Backtick3Constructor {
3696    pub fn build(self) -> Backtick3Node {
3697        let mut builder = CstBuilder::new();
3698        let backtick_3 = builder.embed(self.backtick_3.builder);
3699        let node_id = builder.non_terminal(NonTerminalKind::Backtick3, vec![backtick_3]);
3700        Backtick3Node { node_id, builder }
3701    }
3702}
3703#[derive(bon::Builder)]
3704pub struct Backtick4Constructor {
3705    backtick_4: Backtick4Token,
3706}
3707impl Backtick4Constructor {
3708    pub fn build(self) -> Backtick4Node {
3709        let mut builder = CstBuilder::new();
3710        let backtick_4 = builder.embed(self.backtick_4.builder);
3711        let node_id = builder.non_terminal(NonTerminalKind::Backtick4, vec![backtick_4]);
3712        Backtick4Node { node_id, builder }
3713    }
3714}
3715#[derive(bon::Builder)]
3716pub struct Backtick5Constructor {
3717    backtick_5: Backtick5Token,
3718}
3719impl Backtick5Constructor {
3720    pub fn build(self) -> Backtick5Node {
3721        let mut builder = CstBuilder::new();
3722        let backtick_5 = builder.embed(self.backtick_5.builder);
3723        let node_id = builder.non_terminal(NonTerminalKind::Backtick5, vec![backtick_5]);
3724        Backtick5Node { node_id, builder }
3725    }
3726}
3727#[derive(bon::Builder)]
3728pub struct BacktickDelimConstructor {
3729    backtick_delim: BacktickDelimToken,
3730}
3731impl BacktickDelimConstructor {
3732    pub fn build(self) -> BacktickDelimNode {
3733        let mut builder = CstBuilder::new();
3734        let backtick_delim = builder.embed(self.backtick_delim.builder);
3735        let node_id = builder.non_terminal(NonTerminalKind::BacktickDelim, vec![backtick_delim]);
3736        BacktickDelimNode { node_id, builder }
3737    }
3738}
3739#[derive(bon::Builder)]
3740pub struct BeginConstructor {
3741    l_brace: LBraceToken,
3742}
3743impl BeginConstructor {
3744    pub fn build(self) -> BeginNode {
3745        let mut builder = CstBuilder::new();
3746        let l_brace = builder.embed(self.l_brace.builder);
3747        let node_id = builder.non_terminal(NonTerminalKind::Begin, vec![l_brace]);
3748        BeginNode { node_id, builder }
3749    }
3750}
3751#[derive(bon::Builder)]
3752pub struct BindConstructor {
3753    bind: BindToken,
3754}
3755impl BindConstructor {
3756    pub fn build(self) -> BindNode {
3757        let mut builder = CstBuilder::new();
3758        let bind = builder.embed(self.bind.builder);
3759        let node_id = builder.non_terminal(NonTerminalKind::Bind, vec![bind]);
3760        BindNode { node_id, builder }
3761    }
3762}
3763#[derive(bon::Builder)]
3764pub struct BindingConstructor {
3765    keys: KeysNode,
3766    binding_rhs: BindingRhsNode,
3767}
3768impl BindingConstructor {
3769    pub fn build(self) -> BindingNode {
3770        let mut builder = CstBuilder::new();
3771        let keys = builder.embed(self.keys.builder);
3772        let binding_rhs = builder.embed(self.binding_rhs.builder);
3773        let node_id = builder.non_terminal(NonTerminalKind::Binding, vec![keys, binding_rhs]);
3774        BindingNode { node_id, builder }
3775    }
3776}
3777pub enum BindingRhsConstructor {
3778    ValueBinding(ValueBindingNode),
3779    SectionBinding(SectionBindingNode),
3780    TextBinding(TextBindingNode),
3781}
3782impl BindingRhsConstructor {
3783    pub fn build(self) -> BindingRhsNode {
3784        let mut builder = CstBuilder::new();
3785        let child_id = match self {
3786            Self::ValueBinding(node) => builder.embed(node.builder),
3787            Self::SectionBinding(node) => builder.embed(node.builder),
3788            Self::TextBinding(node) => builder.embed(node.builder),
3789        };
3790        let node_id = builder.non_terminal(NonTerminalKind::BindingRhs, vec![child_id]);
3791        BindingRhsNode { node_id, builder }
3792    }
3793}
3794pub enum BooleanConstructor {
3795    True(TrueNode),
3796    False(FalseNode),
3797}
3798impl BooleanConstructor {
3799    pub fn build(self) -> BooleanNode {
3800        let mut builder = CstBuilder::new();
3801        let child_id = match self {
3802            Self::True(node) => builder.embed(node.builder),
3803            Self::False(node) => builder.embed(node.builder),
3804        };
3805        let node_id = builder.non_terminal(NonTerminalKind::Boolean, vec![child_id]);
3806        BooleanNode { node_id, builder }
3807    }
3808}
3809pub enum CodeBlockConstructor {
3810    CodeBlock3(CodeBlock3Node),
3811    CodeBlock4(CodeBlock4Node),
3812    CodeBlock5(CodeBlock5Node),
3813    CodeBlock6(CodeBlock6Node),
3814}
3815impl CodeBlockConstructor {
3816    pub fn build(self) -> CodeBlockNode {
3817        let mut builder = CstBuilder::new();
3818        let child_id = match self {
3819            Self::CodeBlock3(node) => builder.embed(node.builder),
3820            Self::CodeBlock4(node) => builder.embed(node.builder),
3821            Self::CodeBlock5(node) => builder.embed(node.builder),
3822            Self::CodeBlock6(node) => builder.embed(node.builder),
3823        };
3824        let node_id = builder.non_terminal(NonTerminalKind::CodeBlock, vec![child_id]);
3825        CodeBlockNode { node_id, builder }
3826    }
3827}
3828#[derive(bon::Builder)]
3829pub struct CodeBlock3Constructor {
3830    code_block_start_3: CodeBlockStart3Node,
3831    code_block_3_list: CodeBlock3ListNode,
3832    code_block_end_3: CodeBlockEnd3Node,
3833}
3834impl CodeBlock3Constructor {
3835    pub fn build(self) -> CodeBlock3Node {
3836        let mut builder = CstBuilder::new();
3837        let code_block_start_3 = builder.embed(self.code_block_start_3.builder);
3838        let code_block_3_list = builder.embed(self.code_block_3_list.builder);
3839        let code_block_end_3 = builder.embed(self.code_block_end_3.builder);
3840        let node_id = builder.non_terminal(
3841            NonTerminalKind::CodeBlock3,
3842            vec![code_block_start_3, code_block_3_list, code_block_end_3],
3843        );
3844        CodeBlock3Node { node_id, builder }
3845    }
3846}
3847#[derive(bon::Builder)]
3848pub struct CodeBlock3ListConstructor {
3849    code_block_3_list_group: CodeBlock3ListGroupNode,
3850    code_block_3_list: CodeBlock3ListNode,
3851}
3852impl CodeBlock3ListConstructor {
3853    /// Create an empty node (base case for recursion)
3854    pub fn empty() -> CodeBlock3ListNode {
3855        let mut builder = CstBuilder::new();
3856        let node_id =
3857            builder.non_terminal(NonTerminalKind::CodeBlock3List, Vec::<BuilderNodeId>::new());
3858        CodeBlock3ListNode { node_id, builder }
3859    }
3860    /// Create a node with children (recursive case)
3861    pub fn build(self) -> CodeBlock3ListNode {
3862        let mut builder = CstBuilder::new();
3863        let code_block_3_list_group = builder.embed(self.code_block_3_list_group.builder);
3864        let code_block_3_list = builder.embed(self.code_block_3_list.builder);
3865        let node_id = builder.non_terminal(
3866            NonTerminalKind::CodeBlock3List,
3867            vec![code_block_3_list_group, code_block_3_list],
3868        );
3869        CodeBlock3ListNode { node_id, builder }
3870    }
3871}
3872pub enum CodeBlock3ListGroupConstructor {
3873    NoBacktick(NoBacktickNode),
3874    Backtick2(Backtick2Node),
3875}
3876impl CodeBlock3ListGroupConstructor {
3877    pub fn build(self) -> CodeBlock3ListGroupNode {
3878        let mut builder = CstBuilder::new();
3879        let child_id = match self {
3880            Self::NoBacktick(node) => builder.embed(node.builder),
3881            Self::Backtick2(node) => builder.embed(node.builder),
3882        };
3883        let node_id = builder.non_terminal(NonTerminalKind::CodeBlock3ListGroup, vec![child_id]);
3884        CodeBlock3ListGroupNode { node_id, builder }
3885    }
3886}
3887#[derive(bon::Builder)]
3888pub struct CodeBlock4Constructor {
3889    code_block_start_4: CodeBlockStart4Node,
3890    code_block_4_list: CodeBlock4ListNode,
3891    code_block_end_4: CodeBlockEnd4Node,
3892}
3893impl CodeBlock4Constructor {
3894    pub fn build(self) -> CodeBlock4Node {
3895        let mut builder = CstBuilder::new();
3896        let code_block_start_4 = builder.embed(self.code_block_start_4.builder);
3897        let code_block_4_list = builder.embed(self.code_block_4_list.builder);
3898        let code_block_end_4 = builder.embed(self.code_block_end_4.builder);
3899        let node_id = builder.non_terminal(
3900            NonTerminalKind::CodeBlock4,
3901            vec![code_block_start_4, code_block_4_list, code_block_end_4],
3902        );
3903        CodeBlock4Node { node_id, builder }
3904    }
3905}
3906#[derive(bon::Builder)]
3907pub struct CodeBlock4ListConstructor {
3908    code_block_4_list_group: CodeBlock4ListGroupNode,
3909    code_block_4_list: CodeBlock4ListNode,
3910}
3911impl CodeBlock4ListConstructor {
3912    /// Create an empty node (base case for recursion)
3913    pub fn empty() -> CodeBlock4ListNode {
3914        let mut builder = CstBuilder::new();
3915        let node_id =
3916            builder.non_terminal(NonTerminalKind::CodeBlock4List, Vec::<BuilderNodeId>::new());
3917        CodeBlock4ListNode { node_id, builder }
3918    }
3919    /// Create a node with children (recursive case)
3920    pub fn build(self) -> CodeBlock4ListNode {
3921        let mut builder = CstBuilder::new();
3922        let code_block_4_list_group = builder.embed(self.code_block_4_list_group.builder);
3923        let code_block_4_list = builder.embed(self.code_block_4_list.builder);
3924        let node_id = builder.non_terminal(
3925            NonTerminalKind::CodeBlock4List,
3926            vec![code_block_4_list_group, code_block_4_list],
3927        );
3928        CodeBlock4ListNode { node_id, builder }
3929    }
3930}
3931pub enum CodeBlock4ListGroupConstructor {
3932    NoBacktick(NoBacktickNode),
3933    Backtick3(Backtick3Node),
3934}
3935impl CodeBlock4ListGroupConstructor {
3936    pub fn build(self) -> CodeBlock4ListGroupNode {
3937        let mut builder = CstBuilder::new();
3938        let child_id = match self {
3939            Self::NoBacktick(node) => builder.embed(node.builder),
3940            Self::Backtick3(node) => builder.embed(node.builder),
3941        };
3942        let node_id = builder.non_terminal(NonTerminalKind::CodeBlock4ListGroup, vec![child_id]);
3943        CodeBlock4ListGroupNode { node_id, builder }
3944    }
3945}
3946#[derive(bon::Builder)]
3947pub struct CodeBlock5Constructor {
3948    code_block_start_5: CodeBlockStart5Node,
3949    code_block_5_list: CodeBlock5ListNode,
3950    code_block_end_5: CodeBlockEnd5Node,
3951}
3952impl CodeBlock5Constructor {
3953    pub fn build(self) -> CodeBlock5Node {
3954        let mut builder = CstBuilder::new();
3955        let code_block_start_5 = builder.embed(self.code_block_start_5.builder);
3956        let code_block_5_list = builder.embed(self.code_block_5_list.builder);
3957        let code_block_end_5 = builder.embed(self.code_block_end_5.builder);
3958        let node_id = builder.non_terminal(
3959            NonTerminalKind::CodeBlock5,
3960            vec![code_block_start_5, code_block_5_list, code_block_end_5],
3961        );
3962        CodeBlock5Node { node_id, builder }
3963    }
3964}
3965#[derive(bon::Builder)]
3966pub struct CodeBlock5ListConstructor {
3967    code_block_5_list_group: CodeBlock5ListGroupNode,
3968    code_block_5_list: CodeBlock5ListNode,
3969}
3970impl CodeBlock5ListConstructor {
3971    /// Create an empty node (base case for recursion)
3972    pub fn empty() -> CodeBlock5ListNode {
3973        let mut builder = CstBuilder::new();
3974        let node_id =
3975            builder.non_terminal(NonTerminalKind::CodeBlock5List, Vec::<BuilderNodeId>::new());
3976        CodeBlock5ListNode { node_id, builder }
3977    }
3978    /// Create a node with children (recursive case)
3979    pub fn build(self) -> CodeBlock5ListNode {
3980        let mut builder = CstBuilder::new();
3981        let code_block_5_list_group = builder.embed(self.code_block_5_list_group.builder);
3982        let code_block_5_list = builder.embed(self.code_block_5_list.builder);
3983        let node_id = builder.non_terminal(
3984            NonTerminalKind::CodeBlock5List,
3985            vec![code_block_5_list_group, code_block_5_list],
3986        );
3987        CodeBlock5ListNode { node_id, builder }
3988    }
3989}
3990pub enum CodeBlock5ListGroupConstructor {
3991    NoBacktick(NoBacktickNode),
3992    Backtick4(Backtick4Node),
3993}
3994impl CodeBlock5ListGroupConstructor {
3995    pub fn build(self) -> CodeBlock5ListGroupNode {
3996        let mut builder = CstBuilder::new();
3997        let child_id = match self {
3998            Self::NoBacktick(node) => builder.embed(node.builder),
3999            Self::Backtick4(node) => builder.embed(node.builder),
4000        };
4001        let node_id = builder.non_terminal(NonTerminalKind::CodeBlock5ListGroup, vec![child_id]);
4002        CodeBlock5ListGroupNode { node_id, builder }
4003    }
4004}
4005#[derive(bon::Builder)]
4006pub struct CodeBlock6Constructor {
4007    code_block_start_6: CodeBlockStart6Node,
4008    code_block_6_list: CodeBlock6ListNode,
4009    code_block_end_6: CodeBlockEnd6Node,
4010}
4011impl CodeBlock6Constructor {
4012    pub fn build(self) -> CodeBlock6Node {
4013        let mut builder = CstBuilder::new();
4014        let code_block_start_6 = builder.embed(self.code_block_start_6.builder);
4015        let code_block_6_list = builder.embed(self.code_block_6_list.builder);
4016        let code_block_end_6 = builder.embed(self.code_block_end_6.builder);
4017        let node_id = builder.non_terminal(
4018            NonTerminalKind::CodeBlock6,
4019            vec![code_block_start_6, code_block_6_list, code_block_end_6],
4020        );
4021        CodeBlock6Node { node_id, builder }
4022    }
4023}
4024#[derive(bon::Builder)]
4025pub struct CodeBlock6ListConstructor {
4026    code_block_6_list_group: CodeBlock6ListGroupNode,
4027    code_block_6_list: CodeBlock6ListNode,
4028}
4029impl CodeBlock6ListConstructor {
4030    /// Create an empty node (base case for recursion)
4031    pub fn empty() -> CodeBlock6ListNode {
4032        let mut builder = CstBuilder::new();
4033        let node_id =
4034            builder.non_terminal(NonTerminalKind::CodeBlock6List, Vec::<BuilderNodeId>::new());
4035        CodeBlock6ListNode { node_id, builder }
4036    }
4037    /// Create a node with children (recursive case)
4038    pub fn build(self) -> CodeBlock6ListNode {
4039        let mut builder = CstBuilder::new();
4040        let code_block_6_list_group = builder.embed(self.code_block_6_list_group.builder);
4041        let code_block_6_list = builder.embed(self.code_block_6_list.builder);
4042        let node_id = builder.non_terminal(
4043            NonTerminalKind::CodeBlock6List,
4044            vec![code_block_6_list_group, code_block_6_list],
4045        );
4046        CodeBlock6ListNode { node_id, builder }
4047    }
4048}
4049pub enum CodeBlock6ListGroupConstructor {
4050    NoBacktick(NoBacktickNode),
4051    Backtick5(Backtick5Node),
4052}
4053impl CodeBlock6ListGroupConstructor {
4054    pub fn build(self) -> CodeBlock6ListGroupNode {
4055        let mut builder = CstBuilder::new();
4056        let child_id = match self {
4057            Self::NoBacktick(node) => builder.embed(node.builder),
4058            Self::Backtick5(node) => builder.embed(node.builder),
4059        };
4060        let node_id = builder.non_terminal(NonTerminalKind::CodeBlock6ListGroup, vec![child_id]);
4061        CodeBlock6ListGroupNode { node_id, builder }
4062    }
4063}
4064#[derive(bon::Builder)]
4065pub struct CodeBlockEnd3Constructor {
4066    code_block_end_3: CodeBlockEnd3Token,
4067}
4068impl CodeBlockEnd3Constructor {
4069    pub fn build(self) -> CodeBlockEnd3Node {
4070        let mut builder = CstBuilder::new();
4071        let code_block_end_3 = builder.embed(self.code_block_end_3.builder);
4072        let node_id = builder.non_terminal(NonTerminalKind::CodeBlockEnd3, vec![code_block_end_3]);
4073        CodeBlockEnd3Node { node_id, builder }
4074    }
4075}
4076#[derive(bon::Builder)]
4077pub struct CodeBlockEnd4Constructor {
4078    code_block_end_4: CodeBlockEnd4Token,
4079}
4080impl CodeBlockEnd4Constructor {
4081    pub fn build(self) -> CodeBlockEnd4Node {
4082        let mut builder = CstBuilder::new();
4083        let code_block_end_4 = builder.embed(self.code_block_end_4.builder);
4084        let node_id = builder.non_terminal(NonTerminalKind::CodeBlockEnd4, vec![code_block_end_4]);
4085        CodeBlockEnd4Node { node_id, builder }
4086    }
4087}
4088#[derive(bon::Builder)]
4089pub struct CodeBlockEnd5Constructor {
4090    code_block_end_5: CodeBlockEnd5Token,
4091}
4092impl CodeBlockEnd5Constructor {
4093    pub fn build(self) -> CodeBlockEnd5Node {
4094        let mut builder = CstBuilder::new();
4095        let code_block_end_5 = builder.embed(self.code_block_end_5.builder);
4096        let node_id = builder.non_terminal(NonTerminalKind::CodeBlockEnd5, vec![code_block_end_5]);
4097        CodeBlockEnd5Node { node_id, builder }
4098    }
4099}
4100#[derive(bon::Builder)]
4101pub struct CodeBlockEnd6Constructor {
4102    code_block_end_6: CodeBlockEnd6Token,
4103}
4104impl CodeBlockEnd6Constructor {
4105    pub fn build(self) -> CodeBlockEnd6Node {
4106        let mut builder = CstBuilder::new();
4107        let code_block_end_6 = builder.embed(self.code_block_end_6.builder);
4108        let node_id = builder.non_terminal(NonTerminalKind::CodeBlockEnd6, vec![code_block_end_6]);
4109        CodeBlockEnd6Node { node_id, builder }
4110    }
4111}
4112#[derive(bon::Builder)]
4113pub struct CodeBlockStart3Constructor {
4114    code_block_start_3: CodeBlockStart3Token,
4115}
4116impl CodeBlockStart3Constructor {
4117    pub fn build(self) -> CodeBlockStart3Node {
4118        let mut builder = CstBuilder::new();
4119        let code_block_start_3 = builder.embed(self.code_block_start_3.builder);
4120        let node_id =
4121            builder.non_terminal(NonTerminalKind::CodeBlockStart3, vec![code_block_start_3]);
4122        CodeBlockStart3Node { node_id, builder }
4123    }
4124}
4125#[derive(bon::Builder)]
4126pub struct CodeBlockStart4Constructor {
4127    code_block_start_4: CodeBlockStart4Token,
4128}
4129impl CodeBlockStart4Constructor {
4130    pub fn build(self) -> CodeBlockStart4Node {
4131        let mut builder = CstBuilder::new();
4132        let code_block_start_4 = builder.embed(self.code_block_start_4.builder);
4133        let node_id =
4134            builder.non_terminal(NonTerminalKind::CodeBlockStart4, vec![code_block_start_4]);
4135        CodeBlockStart4Node { node_id, builder }
4136    }
4137}
4138#[derive(bon::Builder)]
4139pub struct CodeBlockStart5Constructor {
4140    code_block_start_5: CodeBlockStart5Token,
4141}
4142impl CodeBlockStart5Constructor {
4143    pub fn build(self) -> CodeBlockStart5Node {
4144        let mut builder = CstBuilder::new();
4145        let code_block_start_5 = builder.embed(self.code_block_start_5.builder);
4146        let node_id =
4147            builder.non_terminal(NonTerminalKind::CodeBlockStart5, vec![code_block_start_5]);
4148        CodeBlockStart5Node { node_id, builder }
4149    }
4150}
4151#[derive(bon::Builder)]
4152pub struct CodeBlockStart6Constructor {
4153    code_block_start_6: CodeBlockStart6Token,
4154}
4155impl CodeBlockStart6Constructor {
4156    pub fn build(self) -> CodeBlockStart6Node {
4157        let mut builder = CstBuilder::new();
4158        let code_block_start_6 = builder.embed(self.code_block_start_6.builder);
4159        let node_id =
4160            builder.non_terminal(NonTerminalKind::CodeBlockStart6, vec![code_block_start_6]);
4161        CodeBlockStart6Node { node_id, builder }
4162    }
4163}
4164#[derive(bon::Builder)]
4165pub struct CommaConstructor {
4166    comma: CommaToken,
4167}
4168impl CommaConstructor {
4169    pub fn build(self) -> CommaNode {
4170        let mut builder = CstBuilder::new();
4171        let comma = builder.embed(self.comma.builder);
4172        let node_id = builder.non_terminal(NonTerminalKind::Comma, vec![comma]);
4173        CommaNode { node_id, builder }
4174    }
4175}
4176#[derive(bon::Builder)]
4177pub struct ContinueConstructor {
4178    esc: EscToken,
4179}
4180impl ContinueConstructor {
4181    pub fn build(self) -> ContinueNode {
4182        let mut builder = CstBuilder::new();
4183        let esc = builder.embed(self.esc.builder);
4184        let node_id = builder.non_terminal(NonTerminalKind::Continue, vec![esc]);
4185        ContinueNode { node_id, builder }
4186    }
4187}
4188pub enum DelimCodeConstructor {
4189    DelimCode3(DelimCode3Node),
4190    DelimCode2(DelimCode2Node),
4191    DelimCode1(DelimCode1Node),
4192}
4193impl DelimCodeConstructor {
4194    pub fn build(self) -> DelimCodeNode {
4195        let mut builder = CstBuilder::new();
4196        let child_id = match self {
4197            Self::DelimCode3(node) => builder.embed(node.builder),
4198            Self::DelimCode2(node) => builder.embed(node.builder),
4199            Self::DelimCode1(node) => builder.embed(node.builder),
4200        };
4201        let node_id = builder.non_terminal(NonTerminalKind::DelimCode, vec![child_id]);
4202        DelimCodeNode { node_id, builder }
4203    }
4204}
4205#[derive(bon::Builder)]
4206pub struct DelimCode1Constructor {
4207    delim_code_start_1: DelimCodeStart1Node,
4208    delim_code_1_list: DelimCode1ListNode,
4209    delim_code_end_1: DelimCodeEnd1Node,
4210}
4211impl DelimCode1Constructor {
4212    pub fn build(self) -> DelimCode1Node {
4213        let mut builder = CstBuilder::new();
4214        let delim_code_start_1 = builder.embed(self.delim_code_start_1.builder);
4215        let delim_code_1_list = builder.embed(self.delim_code_1_list.builder);
4216        let delim_code_end_1 = builder.embed(self.delim_code_end_1.builder);
4217        let node_id = builder.non_terminal(
4218            NonTerminalKind::DelimCode1,
4219            vec![delim_code_start_1, delim_code_1_list, delim_code_end_1],
4220        );
4221        DelimCode1Node { node_id, builder }
4222    }
4223}
4224#[derive(bon::Builder)]
4225pub struct DelimCode1ListConstructor {
4226    delim_code_1_list_group: DelimCode1ListGroupNode,
4227    delim_code_1_list: DelimCode1ListNode,
4228}
4229impl DelimCode1ListConstructor {
4230    /// Create an empty node (base case for recursion)
4231    pub fn empty() -> DelimCode1ListNode {
4232        let mut builder = CstBuilder::new();
4233        let node_id =
4234            builder.non_terminal(NonTerminalKind::DelimCode1List, Vec::<BuilderNodeId>::new());
4235        DelimCode1ListNode { node_id, builder }
4236    }
4237    /// Create a node with children (recursive case)
4238    pub fn build(self) -> DelimCode1ListNode {
4239        let mut builder = CstBuilder::new();
4240        let delim_code_1_list_group = builder.embed(self.delim_code_1_list_group.builder);
4241        let delim_code_1_list = builder.embed(self.delim_code_1_list.builder);
4242        let node_id = builder.non_terminal(
4243            NonTerminalKind::DelimCode1List,
4244            vec![delim_code_1_list_group, delim_code_1_list],
4245        );
4246        DelimCode1ListNode { node_id, builder }
4247    }
4248}
4249pub enum DelimCode1ListGroupConstructor {
4250    NoBacktick(NoBacktickNode),
4251    BacktickDelim(BacktickDelimNode),
4252}
4253impl DelimCode1ListGroupConstructor {
4254    pub fn build(self) -> DelimCode1ListGroupNode {
4255        let mut builder = CstBuilder::new();
4256        let child_id = match self {
4257            Self::NoBacktick(node) => builder.embed(node.builder),
4258            Self::BacktickDelim(node) => builder.embed(node.builder),
4259        };
4260        let node_id = builder.non_terminal(NonTerminalKind::DelimCode1ListGroup, vec![child_id]);
4261        DelimCode1ListGroupNode { node_id, builder }
4262    }
4263}
4264#[derive(bon::Builder)]
4265pub struct DelimCode2Constructor {
4266    delim_code_start_2: DelimCodeStart2Node,
4267    delim_code_2_list: DelimCode2ListNode,
4268    delim_code_end_2: DelimCodeEnd2Node,
4269}
4270impl DelimCode2Constructor {
4271    pub fn build(self) -> DelimCode2Node {
4272        let mut builder = CstBuilder::new();
4273        let delim_code_start_2 = builder.embed(self.delim_code_start_2.builder);
4274        let delim_code_2_list = builder.embed(self.delim_code_2_list.builder);
4275        let delim_code_end_2 = builder.embed(self.delim_code_end_2.builder);
4276        let node_id = builder.non_terminal(
4277            NonTerminalKind::DelimCode2,
4278            vec![delim_code_start_2, delim_code_2_list, delim_code_end_2],
4279        );
4280        DelimCode2Node { node_id, builder }
4281    }
4282}
4283#[derive(bon::Builder)]
4284pub struct DelimCode2ListConstructor {
4285    delim_code_2_list_group: DelimCode2ListGroupNode,
4286    delim_code_2_list: DelimCode2ListNode,
4287}
4288impl DelimCode2ListConstructor {
4289    /// Create an empty node (base case for recursion)
4290    pub fn empty() -> DelimCode2ListNode {
4291        let mut builder = CstBuilder::new();
4292        let node_id =
4293            builder.non_terminal(NonTerminalKind::DelimCode2List, Vec::<BuilderNodeId>::new());
4294        DelimCode2ListNode { node_id, builder }
4295    }
4296    /// Create a node with children (recursive case)
4297    pub fn build(self) -> DelimCode2ListNode {
4298        let mut builder = CstBuilder::new();
4299        let delim_code_2_list_group = builder.embed(self.delim_code_2_list_group.builder);
4300        let delim_code_2_list = builder.embed(self.delim_code_2_list.builder);
4301        let node_id = builder.non_terminal(
4302            NonTerminalKind::DelimCode2List,
4303            vec![delim_code_2_list_group, delim_code_2_list],
4304        );
4305        DelimCode2ListNode { node_id, builder }
4306    }
4307}
4308pub enum DelimCode2ListGroupConstructor {
4309    NoBacktick(NoBacktickNode),
4310    BacktickDelim(BacktickDelimNode),
4311}
4312impl DelimCode2ListGroupConstructor {
4313    pub fn build(self) -> DelimCode2ListGroupNode {
4314        let mut builder = CstBuilder::new();
4315        let child_id = match self {
4316            Self::NoBacktick(node) => builder.embed(node.builder),
4317            Self::BacktickDelim(node) => builder.embed(node.builder),
4318        };
4319        let node_id = builder.non_terminal(NonTerminalKind::DelimCode2ListGroup, vec![child_id]);
4320        DelimCode2ListGroupNode { node_id, builder }
4321    }
4322}
4323#[derive(bon::Builder)]
4324pub struct DelimCode3Constructor {
4325    delim_code_start_3: DelimCodeStart3Node,
4326    delim_code_3_list: DelimCode3ListNode,
4327    delim_code_end_3: DelimCodeEnd3Node,
4328}
4329impl DelimCode3Constructor {
4330    pub fn build(self) -> DelimCode3Node {
4331        let mut builder = CstBuilder::new();
4332        let delim_code_start_3 = builder.embed(self.delim_code_start_3.builder);
4333        let delim_code_3_list = builder.embed(self.delim_code_3_list.builder);
4334        let delim_code_end_3 = builder.embed(self.delim_code_end_3.builder);
4335        let node_id = builder.non_terminal(
4336            NonTerminalKind::DelimCode3,
4337            vec![delim_code_start_3, delim_code_3_list, delim_code_end_3],
4338        );
4339        DelimCode3Node { node_id, builder }
4340    }
4341}
4342#[derive(bon::Builder)]
4343pub struct DelimCode3ListConstructor {
4344    delim_code_3_list_group: DelimCode3ListGroupNode,
4345    delim_code_3_list: DelimCode3ListNode,
4346}
4347impl DelimCode3ListConstructor {
4348    /// Create an empty node (base case for recursion)
4349    pub fn empty() -> DelimCode3ListNode {
4350        let mut builder = CstBuilder::new();
4351        let node_id =
4352            builder.non_terminal(NonTerminalKind::DelimCode3List, Vec::<BuilderNodeId>::new());
4353        DelimCode3ListNode { node_id, builder }
4354    }
4355    /// Create a node with children (recursive case)
4356    pub fn build(self) -> DelimCode3ListNode {
4357        let mut builder = CstBuilder::new();
4358        let delim_code_3_list_group = builder.embed(self.delim_code_3_list_group.builder);
4359        let delim_code_3_list = builder.embed(self.delim_code_3_list.builder);
4360        let node_id = builder.non_terminal(
4361            NonTerminalKind::DelimCode3List,
4362            vec![delim_code_3_list_group, delim_code_3_list],
4363        );
4364        DelimCode3ListNode { node_id, builder }
4365    }
4366}
4367pub enum DelimCode3ListGroupConstructor {
4368    NoBacktick(NoBacktickNode),
4369    BacktickDelim(BacktickDelimNode),
4370}
4371impl DelimCode3ListGroupConstructor {
4372    pub fn build(self) -> DelimCode3ListGroupNode {
4373        let mut builder = CstBuilder::new();
4374        let child_id = match self {
4375            Self::NoBacktick(node) => builder.embed(node.builder),
4376            Self::BacktickDelim(node) => builder.embed(node.builder),
4377        };
4378        let node_id = builder.non_terminal(NonTerminalKind::DelimCode3ListGroup, vec![child_id]);
4379        DelimCode3ListGroupNode { node_id, builder }
4380    }
4381}
4382#[derive(bon::Builder)]
4383pub struct DelimCodeEnd1Constructor {
4384    delim_code_end_1: DelimCodeEnd1Token,
4385}
4386impl DelimCodeEnd1Constructor {
4387    pub fn build(self) -> DelimCodeEnd1Node {
4388        let mut builder = CstBuilder::new();
4389        let delim_code_end_1 = builder.embed(self.delim_code_end_1.builder);
4390        let node_id = builder.non_terminal(NonTerminalKind::DelimCodeEnd1, vec![delim_code_end_1]);
4391        DelimCodeEnd1Node { node_id, builder }
4392    }
4393}
4394#[derive(bon::Builder)]
4395pub struct DelimCodeEnd2Constructor {
4396    delim_code_end_2: DelimCodeEnd2Token,
4397}
4398impl DelimCodeEnd2Constructor {
4399    pub fn build(self) -> DelimCodeEnd2Node {
4400        let mut builder = CstBuilder::new();
4401        let delim_code_end_2 = builder.embed(self.delim_code_end_2.builder);
4402        let node_id = builder.non_terminal(NonTerminalKind::DelimCodeEnd2, vec![delim_code_end_2]);
4403        DelimCodeEnd2Node { node_id, builder }
4404    }
4405}
4406#[derive(bon::Builder)]
4407pub struct DelimCodeEnd3Constructor {
4408    delim_code_end_3: DelimCodeEnd3Token,
4409}
4410impl DelimCodeEnd3Constructor {
4411    pub fn build(self) -> DelimCodeEnd3Node {
4412        let mut builder = CstBuilder::new();
4413        let delim_code_end_3 = builder.embed(self.delim_code_end_3.builder);
4414        let node_id = builder.non_terminal(NonTerminalKind::DelimCodeEnd3, vec![delim_code_end_3]);
4415        DelimCodeEnd3Node { node_id, builder }
4416    }
4417}
4418#[derive(bon::Builder)]
4419pub struct DelimCodeStart1Constructor {
4420    delim_code_start_1: DelimCodeStart1Token,
4421}
4422impl DelimCodeStart1Constructor {
4423    pub fn build(self) -> DelimCodeStart1Node {
4424        let mut builder = CstBuilder::new();
4425        let delim_code_start_1 = builder.embed(self.delim_code_start_1.builder);
4426        let node_id =
4427            builder.non_terminal(NonTerminalKind::DelimCodeStart1, vec![delim_code_start_1]);
4428        DelimCodeStart1Node { node_id, builder }
4429    }
4430}
4431#[derive(bon::Builder)]
4432pub struct DelimCodeStart2Constructor {
4433    delim_code_start_2: DelimCodeStart2Token,
4434}
4435impl DelimCodeStart2Constructor {
4436    pub fn build(self) -> DelimCodeStart2Node {
4437        let mut builder = CstBuilder::new();
4438        let delim_code_start_2 = builder.embed(self.delim_code_start_2.builder);
4439        let node_id =
4440            builder.non_terminal(NonTerminalKind::DelimCodeStart2, vec![delim_code_start_2]);
4441        DelimCodeStart2Node { node_id, builder }
4442    }
4443}
4444#[derive(bon::Builder)]
4445pub struct DelimCodeStart3Constructor {
4446    delim_code_start_3: DelimCodeStart3Token,
4447}
4448impl DelimCodeStart3Constructor {
4449    pub fn build(self) -> DelimCodeStart3Node {
4450        let mut builder = CstBuilder::new();
4451        let delim_code_start_3 = builder.embed(self.delim_code_start_3.builder);
4452        let node_id =
4453            builder.non_terminal(NonTerminalKind::DelimCodeStart3, vec![delim_code_start_3]);
4454        DelimCodeStart3Node { node_id, builder }
4455    }
4456}
4457#[derive(bon::Builder)]
4458pub struct DotConstructor {
4459    dot: DotToken,
4460}
4461impl DotConstructor {
4462    pub fn build(self) -> DotNode {
4463        let mut builder = CstBuilder::new();
4464        let dot = builder.embed(self.dot.builder);
4465        let node_id = builder.non_terminal(NonTerminalKind::Dot, vec![dot]);
4466        DotNode { node_id, builder }
4467    }
4468}
4469#[derive(bon::Builder)]
4470pub struct EndConstructor {
4471    r_brace: RBraceToken,
4472}
4473impl EndConstructor {
4474    pub fn build(self) -> EndNode {
4475        let mut builder = CstBuilder::new();
4476        let r_brace = builder.embed(self.r_brace.builder);
4477        let node_id = builder.non_terminal(NonTerminalKind::End, vec![r_brace]);
4478        EndNode { node_id, builder }
4479    }
4480}
4481#[derive(bon::Builder)]
4482pub struct EureConstructor {
4483    eure_opt: EureOptNode,
4484    eure_bindings: EureBindingsNode,
4485    eure_sections: EureSectionsNode,
4486}
4487impl EureConstructor {
4488    pub fn build(self) -> EureNode {
4489        let mut builder = CstBuilder::new();
4490        let eure_opt = builder.embed(self.eure_opt.builder);
4491        let eure_bindings = builder.embed(self.eure_bindings.builder);
4492        let eure_sections = builder.embed(self.eure_sections.builder);
4493        let node_id = builder.non_terminal(
4494            NonTerminalKind::Eure,
4495            vec![eure_opt, eure_bindings, eure_sections],
4496        );
4497        EureNode { node_id, builder }
4498    }
4499}
4500#[derive(bon::Builder)]
4501pub struct EureBindingsConstructor {
4502    binding: BindingNode,
4503    eure_bindings: EureBindingsNode,
4504}
4505impl EureBindingsConstructor {
4506    /// Create an empty node (base case for recursion)
4507    pub fn empty() -> EureBindingsNode {
4508        let mut builder = CstBuilder::new();
4509        let node_id = builder.non_terminal(NonTerminalKind::EureList, Vec::<BuilderNodeId>::new());
4510        EureBindingsNode { node_id, builder }
4511    }
4512    /// Create a node with children (recursive case)
4513    pub fn build(self) -> EureBindingsNode {
4514        let mut builder = CstBuilder::new();
4515        let binding = builder.embed(self.binding.builder);
4516        let eure_bindings = builder.embed(self.eure_bindings.builder);
4517        let node_id = builder.non_terminal(NonTerminalKind::EureList, vec![binding, eure_bindings]);
4518        EureBindingsNode { node_id, builder }
4519    }
4520}
4521#[derive(bon::Builder)]
4522pub struct EureSectionsConstructor {
4523    section: SectionNode,
4524    eure_sections: EureSectionsNode,
4525}
4526impl EureSectionsConstructor {
4527    /// Create an empty node (base case for recursion)
4528    pub fn empty() -> EureSectionsNode {
4529        let mut builder = CstBuilder::new();
4530        let node_id = builder.non_terminal(NonTerminalKind::EureList0, Vec::<BuilderNodeId>::new());
4531        EureSectionsNode { node_id, builder }
4532    }
4533    /// Create a node with children (recursive case)
4534    pub fn build(self) -> EureSectionsNode {
4535        let mut builder = CstBuilder::new();
4536        let section = builder.embed(self.section.builder);
4537        let eure_sections = builder.embed(self.eure_sections.builder);
4538        let node_id =
4539            builder.non_terminal(NonTerminalKind::EureList0, vec![section, eure_sections]);
4540        EureSectionsNode { node_id, builder }
4541    }
4542}
4543#[derive(bon::Builder)]
4544pub struct EureOptConstructor {
4545    root_binding: Option<RootBindingNode>,
4546}
4547impl EureOptConstructor {
4548    pub fn build(self) -> EureOptNode {
4549        let mut builder = CstBuilder::new();
4550        let children = if let Some(child) = self.root_binding {
4551            vec![builder.embed(child.builder)]
4552        } else {
4553            Vec::<BuilderNodeId>::new()
4554        };
4555        let node_id = builder.non_terminal(NonTerminalKind::EureOpt, children);
4556        EureOptNode { node_id, builder }
4557    }
4558}
4559#[derive(bon::Builder)]
4560pub struct ExtConstructor {
4561    dollar: DollarToken,
4562}
4563impl ExtConstructor {
4564    pub fn build(self) -> ExtNode {
4565        let mut builder = CstBuilder::new();
4566        let dollar = builder.embed(self.dollar.builder);
4567        let node_id = builder.non_terminal(NonTerminalKind::Ext, vec![dollar]);
4568        ExtNode { node_id, builder }
4569    }
4570}
4571#[derive(bon::Builder)]
4572pub struct ExtensionNameSpaceConstructor {
4573    ext: ExtNode,
4574    key_ident: KeyIdentNode,
4575}
4576impl ExtensionNameSpaceConstructor {
4577    pub fn build(self) -> ExtensionNameSpaceNode {
4578        let mut builder = CstBuilder::new();
4579        let ext = builder.embed(self.ext.builder);
4580        let key_ident = builder.embed(self.key_ident.builder);
4581        let node_id =
4582            builder.non_terminal(NonTerminalKind::ExtensionNameSpace, vec![ext, key_ident]);
4583        ExtensionNameSpaceNode { node_id, builder }
4584    }
4585}
4586#[derive(bon::Builder)]
4587pub struct FalseConstructor {
4588    r#false: FalseToken,
4589}
4590impl FalseConstructor {
4591    pub fn build(self) -> FalseNode {
4592        let mut builder = CstBuilder::new();
4593        let r#false = builder.embed(self.r#false.builder);
4594        let node_id = builder.non_terminal(NonTerminalKind::False, vec![r#false]);
4595        FalseNode { node_id, builder }
4596    }
4597}
4598#[derive(bon::Builder)]
4599pub struct FloatConstructor {
4600    float: FloatToken,
4601}
4602impl FloatConstructor {
4603    pub fn build(self) -> FloatNode {
4604        let mut builder = CstBuilder::new();
4605        let float = builder.embed(self.float.builder);
4606        let node_id = builder.non_terminal(NonTerminalKind::Float, vec![float]);
4607        FloatNode { node_id, builder }
4608    }
4609}
4610#[derive(bon::Builder)]
4611pub struct GrammarNewlineConstructor {
4612    grammar_newline: GrammarNewlineToken,
4613}
4614impl GrammarNewlineConstructor {
4615    pub fn build(self) -> GrammarNewlineNode {
4616        let mut builder = CstBuilder::new();
4617        let grammar_newline = builder.embed(self.grammar_newline.builder);
4618        let node_id = builder.non_terminal(NonTerminalKind::GrammarNewline, vec![grammar_newline]);
4619        GrammarNewlineNode { node_id, builder }
4620    }
4621}
4622#[derive(bon::Builder)]
4623pub struct HoleConstructor {
4624    hole: HoleToken,
4625}
4626impl HoleConstructor {
4627    pub fn build(self) -> HoleNode {
4628        let mut builder = CstBuilder::new();
4629        let hole = builder.embed(self.hole.builder);
4630        let node_id = builder.non_terminal(NonTerminalKind::Hole, vec![hole]);
4631        HoleNode { node_id, builder }
4632    }
4633}
4634#[derive(bon::Builder)]
4635pub struct IdentConstructor {
4636    ident: IdentToken,
4637}
4638impl IdentConstructor {
4639    pub fn build(self) -> IdentNode {
4640        let mut builder = CstBuilder::new();
4641        let ident = builder.embed(self.ident.builder);
4642        let node_id = builder.non_terminal(NonTerminalKind::Ident, vec![ident]);
4643        IdentNode { node_id, builder }
4644    }
4645}
4646#[derive(bon::Builder)]
4647pub struct InfConstructor {
4648    inf: InfToken,
4649}
4650impl InfConstructor {
4651    pub fn build(self) -> InfNode {
4652        let mut builder = CstBuilder::new();
4653        let inf = builder.embed(self.inf.builder);
4654        let node_id = builder.non_terminal(NonTerminalKind::Inf, vec![inf]);
4655        InfNode { node_id, builder }
4656    }
4657}
4658pub enum InlineCodeConstructor {
4659    DelimCode(DelimCodeNode),
4660    InlineCode1(InlineCode1Node),
4661}
4662impl InlineCodeConstructor {
4663    pub fn build(self) -> InlineCodeNode {
4664        let mut builder = CstBuilder::new();
4665        let child_id = match self {
4666            Self::DelimCode(node) => builder.embed(node.builder),
4667            Self::InlineCode1(node) => builder.embed(node.builder),
4668        };
4669        let node_id = builder.non_terminal(NonTerminalKind::InlineCode, vec![child_id]);
4670        InlineCodeNode { node_id, builder }
4671    }
4672}
4673#[derive(bon::Builder)]
4674pub struct InlineCode1Constructor {
4675    inline_code_1: InlineCode1Token,
4676}
4677impl InlineCode1Constructor {
4678    pub fn build(self) -> InlineCode1Node {
4679        let mut builder = CstBuilder::new();
4680        let inline_code_1 = builder.embed(self.inline_code_1.builder);
4681        let node_id = builder.non_terminal(NonTerminalKind::InlineCode1, vec![inline_code_1]);
4682        InlineCode1Node { node_id, builder }
4683    }
4684}
4685#[derive(bon::Builder)]
4686pub struct IntegerConstructor {
4687    integer: IntegerToken,
4688}
4689impl IntegerConstructor {
4690    pub fn build(self) -> IntegerNode {
4691        let mut builder = CstBuilder::new();
4692        let integer = builder.embed(self.integer.builder);
4693        let node_id = builder.non_terminal(NonTerminalKind::Integer, vec![integer]);
4694        IntegerNode { node_id, builder }
4695    }
4696}
4697#[derive(bon::Builder)]
4698pub struct KeyConstructor {
4699    key_base: KeyBaseNode,
4700    key_opt: KeyOptNode,
4701}
4702impl KeyConstructor {
4703    pub fn build(self) -> KeyNode {
4704        let mut builder = CstBuilder::new();
4705        let key_base = builder.embed(self.key_base.builder);
4706        let key_opt = builder.embed(self.key_opt.builder);
4707        let node_id = builder.non_terminal(NonTerminalKind::Key, vec![key_base, key_opt]);
4708        KeyNode { node_id, builder }
4709    }
4710}
4711pub enum KeyBaseConstructor {
4712    KeyIdent(KeyIdentNode),
4713    ExtensionNameSpace(ExtensionNameSpaceNode),
4714    String(StringNode),
4715    Integer(IntegerNode),
4716    Float(FloatNode),
4717    KeyTuple(KeyTupleNode),
4718    TupleIndex(TupleIndexNode),
4719}
4720impl KeyBaseConstructor {
4721    pub fn build(self) -> KeyBaseNode {
4722        let mut builder = CstBuilder::new();
4723        let child_id = match self {
4724            Self::KeyIdent(node) => builder.embed(node.builder),
4725            Self::ExtensionNameSpace(node) => builder.embed(node.builder),
4726            Self::String(node) => builder.embed(node.builder),
4727            Self::Integer(node) => builder.embed(node.builder),
4728            Self::Float(node) => builder.embed(node.builder),
4729            Self::KeyTuple(node) => builder.embed(node.builder),
4730            Self::TupleIndex(node) => builder.embed(node.builder),
4731        };
4732        let node_id = builder.non_terminal(NonTerminalKind::KeyBase, vec![child_id]);
4733        KeyBaseNode { node_id, builder }
4734    }
4735}
4736pub enum KeyIdentConstructor {
4737    Ident(IdentNode),
4738    True(TrueNode),
4739    False(FalseNode),
4740    Null(NullNode),
4741}
4742impl KeyIdentConstructor {
4743    pub fn build(self) -> KeyIdentNode {
4744        let mut builder = CstBuilder::new();
4745        let child_id = match self {
4746            Self::Ident(node) => builder.embed(node.builder),
4747            Self::True(node) => builder.embed(node.builder),
4748            Self::False(node) => builder.embed(node.builder),
4749            Self::Null(node) => builder.embed(node.builder),
4750        };
4751        let node_id = builder.non_terminal(NonTerminalKind::KeyIdent, vec![child_id]);
4752        KeyIdentNode { node_id, builder }
4753    }
4754}
4755#[derive(bon::Builder)]
4756pub struct KeyOptConstructor {
4757    array_marker: Option<ArrayMarkerNode>,
4758}
4759impl KeyOptConstructor {
4760    pub fn build(self) -> KeyOptNode {
4761        let mut builder = CstBuilder::new();
4762        let children = if let Some(child) = self.array_marker {
4763            vec![builder.embed(child.builder)]
4764        } else {
4765            Vec::<BuilderNodeId>::new()
4766        };
4767        let node_id = builder.non_terminal(NonTerminalKind::KeyOpt, children);
4768        KeyOptNode { node_id, builder }
4769    }
4770}
4771#[derive(bon::Builder)]
4772pub struct KeyTupleConstructor {
4773    l_paren: LParenNode,
4774    key_tuple_opt: KeyTupleOptNode,
4775    r_paren: RParenNode,
4776}
4777impl KeyTupleConstructor {
4778    pub fn build(self) -> KeyTupleNode {
4779        let mut builder = CstBuilder::new();
4780        let l_paren = builder.embed(self.l_paren.builder);
4781        let key_tuple_opt = builder.embed(self.key_tuple_opt.builder);
4782        let r_paren = builder.embed(self.r_paren.builder);
4783        let node_id = builder.non_terminal(
4784            NonTerminalKind::KeyTuple,
4785            vec![l_paren, key_tuple_opt, r_paren],
4786        );
4787        KeyTupleNode { node_id, builder }
4788    }
4789}
4790#[derive(bon::Builder)]
4791pub struct KeyTupleElementsConstructor {
4792    key_value: KeyValueNode,
4793    key_tuple_elements_opt: KeyTupleElementsOptNode,
4794}
4795impl KeyTupleElementsConstructor {
4796    pub fn build(self) -> KeyTupleElementsNode {
4797        let mut builder = CstBuilder::new();
4798        let key_value = builder.embed(self.key_value.builder);
4799        let key_tuple_elements_opt = builder.embed(self.key_tuple_elements_opt.builder);
4800        let node_id = builder.non_terminal(
4801            NonTerminalKind::KeyTupleElements,
4802            vec![key_value, key_tuple_elements_opt],
4803        );
4804        KeyTupleElementsNode { node_id, builder }
4805    }
4806}
4807#[derive(bon::Builder)]
4808pub struct KeyTupleElementsOptConstructor {
4809    key_tuple_elements_tail: Option<KeyTupleElementsTailNode>,
4810}
4811impl KeyTupleElementsOptConstructor {
4812    pub fn build(self) -> KeyTupleElementsOptNode {
4813        let mut builder = CstBuilder::new();
4814        let children = if let Some(child) = self.key_tuple_elements_tail {
4815            vec![builder.embed(child.builder)]
4816        } else {
4817            Vec::<BuilderNodeId>::new()
4818        };
4819        let node_id = builder.non_terminal(NonTerminalKind::KeyTupleElementsOpt, children);
4820        KeyTupleElementsOptNode { node_id, builder }
4821    }
4822}
4823#[derive(bon::Builder)]
4824pub struct KeyTupleElementsTailConstructor {
4825    comma: CommaNode,
4826    key_tuple_elements_tail_opt: KeyTupleElementsTailOptNode,
4827}
4828impl KeyTupleElementsTailConstructor {
4829    pub fn build(self) -> KeyTupleElementsTailNode {
4830        let mut builder = CstBuilder::new();
4831        let comma = builder.embed(self.comma.builder);
4832        let key_tuple_elements_tail_opt = builder.embed(self.key_tuple_elements_tail_opt.builder);
4833        let node_id = builder.non_terminal(
4834            NonTerminalKind::KeyTupleElementsTail,
4835            vec![comma, key_tuple_elements_tail_opt],
4836        );
4837        KeyTupleElementsTailNode { node_id, builder }
4838    }
4839}
4840#[derive(bon::Builder)]
4841pub struct KeyTupleElementsTailOptConstructor {
4842    key_tuple_elements: Option<KeyTupleElementsNode>,
4843}
4844impl KeyTupleElementsTailOptConstructor {
4845    pub fn build(self) -> KeyTupleElementsTailOptNode {
4846        let mut builder = CstBuilder::new();
4847        let children = if let Some(child) = self.key_tuple_elements {
4848            vec![builder.embed(child.builder)]
4849        } else {
4850            Vec::<BuilderNodeId>::new()
4851        };
4852        let node_id = builder.non_terminal(NonTerminalKind::KeyTupleElementsTailOpt, children);
4853        KeyTupleElementsTailOptNode { node_id, builder }
4854    }
4855}
4856#[derive(bon::Builder)]
4857pub struct KeyTupleOptConstructor {
4858    key_tuple_elements: Option<KeyTupleElementsNode>,
4859}
4860impl KeyTupleOptConstructor {
4861    pub fn build(self) -> KeyTupleOptNode {
4862        let mut builder = CstBuilder::new();
4863        let children = if let Some(child) = self.key_tuple_elements {
4864            vec![builder.embed(child.builder)]
4865        } else {
4866            Vec::<BuilderNodeId>::new()
4867        };
4868        let node_id = builder.non_terminal(NonTerminalKind::KeyTupleOpt, children);
4869        KeyTupleOptNode { node_id, builder }
4870    }
4871}
4872pub enum KeyValueConstructor {
4873    Integer(IntegerNode),
4874    Boolean(BooleanNode),
4875    Str(StrNode),
4876    KeyTuple(KeyTupleNode),
4877}
4878impl KeyValueConstructor {
4879    pub fn build(self) -> KeyValueNode {
4880        let mut builder = CstBuilder::new();
4881        let child_id = match self {
4882            Self::Integer(node) => builder.embed(node.builder),
4883            Self::Boolean(node) => builder.embed(node.builder),
4884            Self::Str(node) => builder.embed(node.builder),
4885            Self::KeyTuple(node) => builder.embed(node.builder),
4886        };
4887        let node_id = builder.non_terminal(NonTerminalKind::KeyValue, vec![child_id]);
4888        KeyValueNode { node_id, builder }
4889    }
4890}
4891#[derive(bon::Builder)]
4892pub struct KeysConstructor {
4893    key: KeyNode,
4894    keys_list: KeysListNode,
4895}
4896impl KeysConstructor {
4897    pub fn build(self) -> KeysNode {
4898        let mut builder = CstBuilder::new();
4899        let key = builder.embed(self.key.builder);
4900        let keys_list = builder.embed(self.keys_list.builder);
4901        let node_id = builder.non_terminal(NonTerminalKind::Keys, vec![key, keys_list]);
4902        KeysNode { node_id, builder }
4903    }
4904}
4905#[derive(bon::Builder)]
4906pub struct KeysListConstructor {
4907    dot: DotNode,
4908    key: KeyNode,
4909    keys_list: KeysListNode,
4910}
4911impl KeysListConstructor {
4912    /// Create an empty node (base case for recursion)
4913    pub fn empty() -> KeysListNode {
4914        let mut builder = CstBuilder::new();
4915        let node_id = builder.non_terminal(NonTerminalKind::KeysList, Vec::<BuilderNodeId>::new());
4916        KeysListNode { node_id, builder }
4917    }
4918    /// Create a node with children (recursive case)
4919    pub fn build(self) -> KeysListNode {
4920        let mut builder = CstBuilder::new();
4921        let dot = builder.embed(self.dot.builder);
4922        let key = builder.embed(self.key.builder);
4923        let keys_list = builder.embed(self.keys_list.builder);
4924        let node_id = builder.non_terminal(NonTerminalKind::KeysList, vec![dot, key, keys_list]);
4925        KeysListNode { node_id, builder }
4926    }
4927}
4928#[derive(bon::Builder)]
4929pub struct LParenConstructor {
4930    l_paren: LParenToken,
4931}
4932impl LParenConstructor {
4933    pub fn build(self) -> LParenNode {
4934        let mut builder = CstBuilder::new();
4935        let l_paren = builder.embed(self.l_paren.builder);
4936        let node_id = builder.non_terminal(NonTerminalKind::LParen, vec![l_paren]);
4937        LParenNode { node_id, builder }
4938    }
4939}
4940#[derive(bon::Builder)]
4941pub struct LitStrConstructor {
4942    lit_str: LitStrToken,
4943}
4944impl LitStrConstructor {
4945    pub fn build(self) -> LitStrNode {
4946        let mut builder = CstBuilder::new();
4947        let lit_str = builder.embed(self.lit_str.builder);
4948        let node_id = builder.non_terminal(NonTerminalKind::LitStr, vec![lit_str]);
4949        LitStrNode { node_id, builder }
4950    }
4951}
4952#[derive(bon::Builder)]
4953pub struct LitStr1Constructor {
4954    lit_str_1_start: LitStr1StartNode,
4955    lit_str_1_list: LitStr1ListNode,
4956    lit_str_1_end: LitStr1EndNode,
4957}
4958impl LitStr1Constructor {
4959    pub fn build(self) -> LitStr1Node {
4960        let mut builder = CstBuilder::new();
4961        let lit_str_1_start = builder.embed(self.lit_str_1_start.builder);
4962        let lit_str_1_list = builder.embed(self.lit_str_1_list.builder);
4963        let lit_str_1_end = builder.embed(self.lit_str_1_end.builder);
4964        let node_id = builder.non_terminal(
4965            NonTerminalKind::LitStr1,
4966            vec![lit_str_1_start, lit_str_1_list, lit_str_1_end],
4967        );
4968        LitStr1Node { node_id, builder }
4969    }
4970}
4971#[derive(bon::Builder)]
4972pub struct LitStr1EndConstructor {
4973    lit_str_1_end: LitStr1EndToken,
4974}
4975impl LitStr1EndConstructor {
4976    pub fn build(self) -> LitStr1EndNode {
4977        let mut builder = CstBuilder::new();
4978        let lit_str_1_end = builder.embed(self.lit_str_1_end.builder);
4979        let node_id = builder.non_terminal(NonTerminalKind::LitStr1End, vec![lit_str_1_end]);
4980        LitStr1EndNode { node_id, builder }
4981    }
4982}
4983#[derive(bon::Builder)]
4984pub struct LitStr1ListConstructor {
4985    lit_str_1_list_group: LitStr1ListGroupNode,
4986    lit_str_1_list: LitStr1ListNode,
4987}
4988impl LitStr1ListConstructor {
4989    /// Create an empty node (base case for recursion)
4990    pub fn empty() -> LitStr1ListNode {
4991        let mut builder = CstBuilder::new();
4992        let node_id =
4993            builder.non_terminal(NonTerminalKind::LitStr1List, Vec::<BuilderNodeId>::new());
4994        LitStr1ListNode { node_id, builder }
4995    }
4996    /// Create a node with children (recursive case)
4997    pub fn build(self) -> LitStr1ListNode {
4998        let mut builder = CstBuilder::new();
4999        let lit_str_1_list_group = builder.embed(self.lit_str_1_list_group.builder);
5000        let lit_str_1_list = builder.embed(self.lit_str_1_list.builder);
5001        let node_id = builder.non_terminal(
5002            NonTerminalKind::LitStr1List,
5003            vec![lit_str_1_list_group, lit_str_1_list],
5004        );
5005        LitStr1ListNode { node_id, builder }
5006    }
5007}
5008pub enum LitStr1ListGroupConstructor {
5009    NoSQuote(NoSQuoteNode),
5010    SQuote(SQuoteNode),
5011}
5012impl LitStr1ListGroupConstructor {
5013    pub fn build(self) -> LitStr1ListGroupNode {
5014        let mut builder = CstBuilder::new();
5015        let child_id = match self {
5016            Self::NoSQuote(node) => builder.embed(node.builder),
5017            Self::SQuote(node) => builder.embed(node.builder),
5018        };
5019        let node_id = builder.non_terminal(NonTerminalKind::LitStr1ListGroup, vec![child_id]);
5020        LitStr1ListGroupNode { node_id, builder }
5021    }
5022}
5023#[derive(bon::Builder)]
5024pub struct LitStr1StartConstructor {
5025    lit_str_1_start: LitStr1StartToken,
5026}
5027impl LitStr1StartConstructor {
5028    pub fn build(self) -> LitStr1StartNode {
5029        let mut builder = CstBuilder::new();
5030        let lit_str_1_start = builder.embed(self.lit_str_1_start.builder);
5031        let node_id = builder.non_terminal(NonTerminalKind::LitStr1Start, vec![lit_str_1_start]);
5032        LitStr1StartNode { node_id, builder }
5033    }
5034}
5035#[derive(bon::Builder)]
5036pub struct LitStr2Constructor {
5037    lit_str_2_start: LitStr2StartNode,
5038    lit_str_2_list: LitStr2ListNode,
5039    lit_str_2_end: LitStr2EndNode,
5040}
5041impl LitStr2Constructor {
5042    pub fn build(self) -> LitStr2Node {
5043        let mut builder = CstBuilder::new();
5044        let lit_str_2_start = builder.embed(self.lit_str_2_start.builder);
5045        let lit_str_2_list = builder.embed(self.lit_str_2_list.builder);
5046        let lit_str_2_end = builder.embed(self.lit_str_2_end.builder);
5047        let node_id = builder.non_terminal(
5048            NonTerminalKind::LitStr2,
5049            vec![lit_str_2_start, lit_str_2_list, lit_str_2_end],
5050        );
5051        LitStr2Node { node_id, builder }
5052    }
5053}
5054#[derive(bon::Builder)]
5055pub struct LitStr2EndConstructor {
5056    lit_str_2_end: LitStr2EndToken,
5057}
5058impl LitStr2EndConstructor {
5059    pub fn build(self) -> LitStr2EndNode {
5060        let mut builder = CstBuilder::new();
5061        let lit_str_2_end = builder.embed(self.lit_str_2_end.builder);
5062        let node_id = builder.non_terminal(NonTerminalKind::LitStr2End, vec![lit_str_2_end]);
5063        LitStr2EndNode { node_id, builder }
5064    }
5065}
5066#[derive(bon::Builder)]
5067pub struct LitStr2ListConstructor {
5068    lit_str_2_list_group: LitStr2ListGroupNode,
5069    lit_str_2_list: LitStr2ListNode,
5070}
5071impl LitStr2ListConstructor {
5072    /// Create an empty node (base case for recursion)
5073    pub fn empty() -> LitStr2ListNode {
5074        let mut builder = CstBuilder::new();
5075        let node_id =
5076            builder.non_terminal(NonTerminalKind::LitStr2List, Vec::<BuilderNodeId>::new());
5077        LitStr2ListNode { node_id, builder }
5078    }
5079    /// Create a node with children (recursive case)
5080    pub fn build(self) -> LitStr2ListNode {
5081        let mut builder = CstBuilder::new();
5082        let lit_str_2_list_group = builder.embed(self.lit_str_2_list_group.builder);
5083        let lit_str_2_list = builder.embed(self.lit_str_2_list.builder);
5084        let node_id = builder.non_terminal(
5085            NonTerminalKind::LitStr2List,
5086            vec![lit_str_2_list_group, lit_str_2_list],
5087        );
5088        LitStr2ListNode { node_id, builder }
5089    }
5090}
5091pub enum LitStr2ListGroupConstructor {
5092    NoSQuote(NoSQuoteNode),
5093    SQuote(SQuoteNode),
5094}
5095impl LitStr2ListGroupConstructor {
5096    pub fn build(self) -> LitStr2ListGroupNode {
5097        let mut builder = CstBuilder::new();
5098        let child_id = match self {
5099            Self::NoSQuote(node) => builder.embed(node.builder),
5100            Self::SQuote(node) => builder.embed(node.builder),
5101        };
5102        let node_id = builder.non_terminal(NonTerminalKind::LitStr2ListGroup, vec![child_id]);
5103        LitStr2ListGroupNode { node_id, builder }
5104    }
5105}
5106#[derive(bon::Builder)]
5107pub struct LitStr2StartConstructor {
5108    lit_str_2_start: LitStr2StartToken,
5109}
5110impl LitStr2StartConstructor {
5111    pub fn build(self) -> LitStr2StartNode {
5112        let mut builder = CstBuilder::new();
5113        let lit_str_2_start = builder.embed(self.lit_str_2_start.builder);
5114        let node_id = builder.non_terminal(NonTerminalKind::LitStr2Start, vec![lit_str_2_start]);
5115        LitStr2StartNode { node_id, builder }
5116    }
5117}
5118#[derive(bon::Builder)]
5119pub struct LitStr3Constructor {
5120    lit_str_3_start: LitStr3StartNode,
5121    lit_str_3_list: LitStr3ListNode,
5122    lit_str_3_end: LitStr3EndNode,
5123}
5124impl LitStr3Constructor {
5125    pub fn build(self) -> LitStr3Node {
5126        let mut builder = CstBuilder::new();
5127        let lit_str_3_start = builder.embed(self.lit_str_3_start.builder);
5128        let lit_str_3_list = builder.embed(self.lit_str_3_list.builder);
5129        let lit_str_3_end = builder.embed(self.lit_str_3_end.builder);
5130        let node_id = builder.non_terminal(
5131            NonTerminalKind::LitStr3,
5132            vec![lit_str_3_start, lit_str_3_list, lit_str_3_end],
5133        );
5134        LitStr3Node { node_id, builder }
5135    }
5136}
5137#[derive(bon::Builder)]
5138pub struct LitStr3EndConstructor {
5139    lit_str_3_end: LitStr3EndToken,
5140}
5141impl LitStr3EndConstructor {
5142    pub fn build(self) -> LitStr3EndNode {
5143        let mut builder = CstBuilder::new();
5144        let lit_str_3_end = builder.embed(self.lit_str_3_end.builder);
5145        let node_id = builder.non_terminal(NonTerminalKind::LitStr3End, vec![lit_str_3_end]);
5146        LitStr3EndNode { node_id, builder }
5147    }
5148}
5149#[derive(bon::Builder)]
5150pub struct LitStr3ListConstructor {
5151    lit_str_3_list_group: LitStr3ListGroupNode,
5152    lit_str_3_list: LitStr3ListNode,
5153}
5154impl LitStr3ListConstructor {
5155    /// Create an empty node (base case for recursion)
5156    pub fn empty() -> LitStr3ListNode {
5157        let mut builder = CstBuilder::new();
5158        let node_id =
5159            builder.non_terminal(NonTerminalKind::LitStr3List, Vec::<BuilderNodeId>::new());
5160        LitStr3ListNode { node_id, builder }
5161    }
5162    /// Create a node with children (recursive case)
5163    pub fn build(self) -> LitStr3ListNode {
5164        let mut builder = CstBuilder::new();
5165        let lit_str_3_list_group = builder.embed(self.lit_str_3_list_group.builder);
5166        let lit_str_3_list = builder.embed(self.lit_str_3_list.builder);
5167        let node_id = builder.non_terminal(
5168            NonTerminalKind::LitStr3List,
5169            vec![lit_str_3_list_group, lit_str_3_list],
5170        );
5171        LitStr3ListNode { node_id, builder }
5172    }
5173}
5174pub enum LitStr3ListGroupConstructor {
5175    NoSQuote(NoSQuoteNode),
5176    SQuote(SQuoteNode),
5177}
5178impl LitStr3ListGroupConstructor {
5179    pub fn build(self) -> LitStr3ListGroupNode {
5180        let mut builder = CstBuilder::new();
5181        let child_id = match self {
5182            Self::NoSQuote(node) => builder.embed(node.builder),
5183            Self::SQuote(node) => builder.embed(node.builder),
5184        };
5185        let node_id = builder.non_terminal(NonTerminalKind::LitStr3ListGroup, vec![child_id]);
5186        LitStr3ListGroupNode { node_id, builder }
5187    }
5188}
5189#[derive(bon::Builder)]
5190pub struct LitStr3StartConstructor {
5191    lit_str_3_start: LitStr3StartToken,
5192}
5193impl LitStr3StartConstructor {
5194    pub fn build(self) -> LitStr3StartNode {
5195        let mut builder = CstBuilder::new();
5196        let lit_str_3_start = builder.embed(self.lit_str_3_start.builder);
5197        let node_id = builder.non_terminal(NonTerminalKind::LitStr3Start, vec![lit_str_3_start]);
5198        LitStr3StartNode { node_id, builder }
5199    }
5200}
5201#[derive(bon::Builder)]
5202pub struct MapBindConstructor {
5203    map_bind: MapBindToken,
5204}
5205impl MapBindConstructor {
5206    pub fn build(self) -> MapBindNode {
5207        let mut builder = CstBuilder::new();
5208        let map_bind = builder.embed(self.map_bind.builder);
5209        let node_id = builder.non_terminal(NonTerminalKind::MapBind, vec![map_bind]);
5210        MapBindNode { node_id, builder }
5211    }
5212}
5213#[derive(bon::Builder)]
5214pub struct NaNConstructor {
5215    na_n: NaNToken,
5216}
5217impl NaNConstructor {
5218    pub fn build(self) -> NaNNode {
5219        let mut builder = CstBuilder::new();
5220        let na_n = builder.embed(self.na_n.builder);
5221        let node_id = builder.non_terminal(NonTerminalKind::NaN, vec![na_n]);
5222        NaNNode { node_id, builder }
5223    }
5224}
5225#[derive(bon::Builder)]
5226pub struct NoBacktickConstructor {
5227    no_backtick: NoBacktickToken,
5228}
5229impl NoBacktickConstructor {
5230    pub fn build(self) -> NoBacktickNode {
5231        let mut builder = CstBuilder::new();
5232        let no_backtick = builder.embed(self.no_backtick.builder);
5233        let node_id = builder.non_terminal(NonTerminalKind::NoBacktick, vec![no_backtick]);
5234        NoBacktickNode { node_id, builder }
5235    }
5236}
5237#[derive(bon::Builder)]
5238pub struct NoSQuoteConstructor {
5239    no_s_quote: NoSQuoteToken,
5240}
5241impl NoSQuoteConstructor {
5242    pub fn build(self) -> NoSQuoteNode {
5243        let mut builder = CstBuilder::new();
5244        let no_s_quote = builder.embed(self.no_s_quote.builder);
5245        let node_id = builder.non_terminal(NonTerminalKind::NoSQuote, vec![no_s_quote]);
5246        NoSQuoteNode { node_id, builder }
5247    }
5248}
5249#[derive(bon::Builder)]
5250pub struct NullConstructor {
5251    null: NullToken,
5252}
5253impl NullConstructor {
5254    pub fn build(self) -> NullNode {
5255        let mut builder = CstBuilder::new();
5256        let null = builder.embed(self.null.builder);
5257        let node_id = builder.non_terminal(NonTerminalKind::Null, vec![null]);
5258        NullNode { node_id, builder }
5259    }
5260}
5261pub enum NumberConstructor {
5262    Float(FloatNode),
5263    Integer(IntegerNode),
5264    Inf(InfNode),
5265    NaN(NaNNode),
5266}
5267impl NumberConstructor {
5268    pub fn build(self) -> NumberNode {
5269        let mut builder = CstBuilder::new();
5270        let child_id = match self {
5271            Self::Float(node) => builder.embed(node.builder),
5272            Self::Integer(node) => builder.embed(node.builder),
5273            Self::Inf(node) => builder.embed(node.builder),
5274            Self::NaN(node) => builder.embed(node.builder),
5275        };
5276        let node_id = builder.non_terminal(NonTerminalKind::Number, vec![child_id]);
5277        NumberNode { node_id, builder }
5278    }
5279}
5280#[derive(bon::Builder)]
5281pub struct ObjectConstructor {
5282    begin: BeginNode,
5283    object_opt: ObjectOptNode,
5284    object_list: ObjectListNode,
5285    end: EndNode,
5286}
5287impl ObjectConstructor {
5288    pub fn build(self) -> ObjectNode {
5289        let mut builder = CstBuilder::new();
5290        let begin = builder.embed(self.begin.builder);
5291        let object_opt = builder.embed(self.object_opt.builder);
5292        let object_list = builder.embed(self.object_list.builder);
5293        let end = builder.embed(self.end.builder);
5294        let node_id = builder.non_terminal(
5295            NonTerminalKind::Object,
5296            vec![begin, object_opt, object_list, end],
5297        );
5298        ObjectNode { node_id, builder }
5299    }
5300}
5301#[derive(bon::Builder)]
5302pub struct ObjectListConstructor {
5303    keys: KeysNode,
5304    map_bind: MapBindNode,
5305    value: ValueNode,
5306    object_opt_0: ObjectOpt0Node,
5307    object_list: ObjectListNode,
5308}
5309impl ObjectListConstructor {
5310    /// Create an empty node (base case for recursion)
5311    pub fn empty() -> ObjectListNode {
5312        let mut builder = CstBuilder::new();
5313        let node_id =
5314            builder.non_terminal(NonTerminalKind::ObjectList, Vec::<BuilderNodeId>::new());
5315        ObjectListNode { node_id, builder }
5316    }
5317    /// Create a node with children (recursive case)
5318    pub fn build(self) -> ObjectListNode {
5319        let mut builder = CstBuilder::new();
5320        let keys = builder.embed(self.keys.builder);
5321        let map_bind = builder.embed(self.map_bind.builder);
5322        let value = builder.embed(self.value.builder);
5323        let object_opt_0 = builder.embed(self.object_opt_0.builder);
5324        let object_list = builder.embed(self.object_list.builder);
5325        let node_id = builder.non_terminal(
5326            NonTerminalKind::ObjectList,
5327            vec![keys, map_bind, value, object_opt_0, object_list],
5328        );
5329        ObjectListNode { node_id, builder }
5330    }
5331}
5332#[derive(bon::Builder)]
5333pub struct ObjectOptConstructor {
5334    value_binding: ValueBindingNode,
5335    object_opt_1: ObjectOpt1Node,
5336}
5337impl ObjectOptConstructor {
5338    pub fn build(self) -> ObjectOptNode {
5339        let mut builder = CstBuilder::new();
5340        let value_binding = builder.embed(self.value_binding.builder);
5341        let object_opt_1 = builder.embed(self.object_opt_1.builder);
5342        let node_id = builder.non_terminal(
5343            NonTerminalKind::ObjectOpt,
5344            vec![value_binding, object_opt_1],
5345        );
5346        ObjectOptNode { node_id, builder }
5347    }
5348}
5349#[derive(bon::Builder)]
5350pub struct ObjectOpt0Constructor {
5351    comma: Option<CommaNode>,
5352}
5353impl ObjectOpt0Constructor {
5354    pub fn build(self) -> ObjectOpt0Node {
5355        let mut builder = CstBuilder::new();
5356        let children = if let Some(child) = self.comma {
5357            vec![builder.embed(child.builder)]
5358        } else {
5359            Vec::<BuilderNodeId>::new()
5360        };
5361        let node_id = builder.non_terminal(NonTerminalKind::ObjectOpt0, children);
5362        ObjectOpt0Node { node_id, builder }
5363    }
5364}
5365#[derive(bon::Builder)]
5366pub struct ObjectOpt1Constructor {
5367    comma: Option<CommaNode>,
5368}
5369impl ObjectOpt1Constructor {
5370    pub fn build(self) -> ObjectOpt1Node {
5371        let mut builder = CstBuilder::new();
5372        let children = if let Some(child) = self.comma {
5373            vec![builder.embed(child.builder)]
5374        } else {
5375            Vec::<BuilderNodeId>::new()
5376        };
5377        let node_id = builder.non_terminal(NonTerminalKind::ObjectOpt1, children);
5378        ObjectOpt1Node { node_id, builder }
5379    }
5380}
5381#[derive(bon::Builder)]
5382pub struct RParenConstructor {
5383    r_paren: RParenToken,
5384}
5385impl RParenConstructor {
5386    pub fn build(self) -> RParenNode {
5387        let mut builder = CstBuilder::new();
5388        let r_paren = builder.embed(self.r_paren.builder);
5389        let node_id = builder.non_terminal(NonTerminalKind::RParen, vec![r_paren]);
5390        RParenNode { node_id, builder }
5391    }
5392}
5393pub enum RootBindingConstructor {
5394    ValueBinding(ValueBindingNode),
5395    TextBinding(TextBindingNode),
5396}
5397impl RootBindingConstructor {
5398    pub fn build(self) -> RootBindingNode {
5399        let mut builder = CstBuilder::new();
5400        let child_id = match self {
5401            Self::ValueBinding(node) => builder.embed(node.builder),
5402            Self::TextBinding(node) => builder.embed(node.builder),
5403        };
5404        let node_id = builder.non_terminal(NonTerminalKind::RootBinding, vec![child_id]);
5405        RootBindingNode { node_id, builder }
5406    }
5407}
5408#[derive(bon::Builder)]
5409pub struct SQuoteConstructor {
5410    s_quote: SQuoteToken,
5411}
5412impl SQuoteConstructor {
5413    pub fn build(self) -> SQuoteNode {
5414        let mut builder = CstBuilder::new();
5415        let s_quote = builder.embed(self.s_quote.builder);
5416        let node_id = builder.non_terminal(NonTerminalKind::SQuote, vec![s_quote]);
5417        SQuoteNode { node_id, builder }
5418    }
5419}
5420#[derive(bon::Builder)]
5421pub struct SectionConstructor {
5422    at: AtNode,
5423    keys: KeysNode,
5424    section_body: SectionBodyNode,
5425}
5426impl SectionConstructor {
5427    pub fn build(self) -> SectionNode {
5428        let mut builder = CstBuilder::new();
5429        let at = builder.embed(self.at.builder);
5430        let keys = builder.embed(self.keys.builder);
5431        let section_body = builder.embed(self.section_body.builder);
5432        let node_id = builder.non_terminal(NonTerminalKind::Section, vec![at, keys, section_body]);
5433        SectionNode { node_id, builder }
5434    }
5435}
5436#[derive(bon::Builder)]
5437pub struct SectionBindingConstructor {
5438    begin: BeginNode,
5439    eure: EureNode,
5440    end: EndNode,
5441}
5442impl SectionBindingConstructor {
5443    pub fn build(self) -> SectionBindingNode {
5444        let mut builder = CstBuilder::new();
5445        let begin = builder.embed(self.begin.builder);
5446        let eure = builder.embed(self.eure.builder);
5447        let end = builder.embed(self.end.builder);
5448        let node_id = builder.non_terminal(NonTerminalKind::SectionBinding, vec![begin, eure, end]);
5449        SectionBindingNode { node_id, builder }
5450    }
5451}
5452pub enum SectionBodyConstructor {
5453    SectionBodyOpt(SectionBodyOptNode),
5454    Begin(BeginNode),
5455}
5456impl SectionBodyConstructor {
5457    pub fn build(self) -> SectionBodyNode {
5458        let mut builder = CstBuilder::new();
5459        let child_id = match self {
5460            Self::SectionBodyOpt(node) => builder.embed(node.builder),
5461            Self::Begin(node) => builder.embed(node.builder),
5462        };
5463        let node_id = builder.non_terminal(NonTerminalKind::SectionBody, vec![child_id]);
5464        SectionBodyNode { node_id, builder }
5465    }
5466}
5467#[derive(bon::Builder)]
5468pub struct SectionBodyListConstructor {
5469    binding: BindingNode,
5470    section_body_list: SectionBodyListNode,
5471}
5472impl SectionBodyListConstructor {
5473    /// Create an empty node (base case for recursion)
5474    pub fn empty() -> SectionBodyListNode {
5475        let mut builder = CstBuilder::new();
5476        let node_id = builder.non_terminal(
5477            NonTerminalKind::SectionBodyList,
5478            Vec::<BuilderNodeId>::new(),
5479        );
5480        SectionBodyListNode { node_id, builder }
5481    }
5482    /// Create a node with children (recursive case)
5483    pub fn build(self) -> SectionBodyListNode {
5484        let mut builder = CstBuilder::new();
5485        let binding = builder.embed(self.binding.builder);
5486        let section_body_list = builder.embed(self.section_body_list.builder);
5487        let node_id = builder.non_terminal(
5488            NonTerminalKind::SectionBodyList,
5489            vec![binding, section_body_list],
5490        );
5491        SectionBodyListNode { node_id, builder }
5492    }
5493}
5494#[derive(bon::Builder)]
5495pub struct SectionBodyOptConstructor {
5496    root_binding: Option<RootBindingNode>,
5497}
5498impl SectionBodyOptConstructor {
5499    pub fn build(self) -> SectionBodyOptNode {
5500        let mut builder = CstBuilder::new();
5501        let children = if let Some(child) = self.root_binding {
5502            vec![builder.embed(child.builder)]
5503        } else {
5504            Vec::<BuilderNodeId>::new()
5505        };
5506        let node_id = builder.non_terminal(NonTerminalKind::SectionBodyOpt, children);
5507        SectionBodyOptNode { node_id, builder }
5508    }
5509}
5510#[derive(bon::Builder)]
5511pub struct StrConstructor {
5512    str: StrToken,
5513}
5514impl StrConstructor {
5515    pub fn build(self) -> StrNode {
5516        let mut builder = CstBuilder::new();
5517        let str = builder.embed(self.str.builder);
5518        let node_id = builder.non_terminal(NonTerminalKind::Str, vec![str]);
5519        StrNode { node_id, builder }
5520    }
5521}
5522pub enum StringConstructor {
5523    Str(StrNode),
5524    LitStr(LitStrNode),
5525    LitStr1(LitStr1Node),
5526    LitStr2(LitStr2Node),
5527    LitStr3(LitStr3Node),
5528}
5529impl StringConstructor {
5530    pub fn build(self) -> StringNode {
5531        let mut builder = CstBuilder::new();
5532        let child_id = match self {
5533            Self::Str(node) => builder.embed(node.builder),
5534            Self::LitStr(node) => builder.embed(node.builder),
5535            Self::LitStr1(node) => builder.embed(node.builder),
5536            Self::LitStr2(node) => builder.embed(node.builder),
5537            Self::LitStr3(node) => builder.embed(node.builder),
5538        };
5539        let node_id = builder.non_terminal(NonTerminalKind::String, vec![child_id]);
5540        StringNode { node_id, builder }
5541    }
5542}
5543#[derive(bon::Builder)]
5544pub struct StringsConstructor {
5545    string: StringNode,
5546    strings_list: StringsListNode,
5547}
5548impl StringsConstructor {
5549    pub fn build(self) -> StringsNode {
5550        let mut builder = CstBuilder::new();
5551        let string = builder.embed(self.string.builder);
5552        let strings_list = builder.embed(self.strings_list.builder);
5553        let node_id = builder.non_terminal(NonTerminalKind::Strings, vec![string, strings_list]);
5554        StringsNode { node_id, builder }
5555    }
5556}
5557#[derive(bon::Builder)]
5558pub struct StringsListConstructor {
5559    r#continue: ContinueNode,
5560    string: StringNode,
5561    strings_list: StringsListNode,
5562}
5563impl StringsListConstructor {
5564    /// Create an empty node (base case for recursion)
5565    pub fn empty() -> StringsListNode {
5566        let mut builder = CstBuilder::new();
5567        let node_id =
5568            builder.non_terminal(NonTerminalKind::StringsList, Vec::<BuilderNodeId>::new());
5569        StringsListNode { node_id, builder }
5570    }
5571    /// Create a node with children (recursive case)
5572    pub fn build(self) -> StringsListNode {
5573        let mut builder = CstBuilder::new();
5574        let r#continue = builder.embed(self.r#continue.builder);
5575        let string = builder.embed(self.string.builder);
5576        let strings_list = builder.embed(self.strings_list.builder);
5577        let node_id = builder.non_terminal(
5578            NonTerminalKind::StringsList,
5579            vec![r#continue, string, strings_list],
5580        );
5581        StringsListNode { node_id, builder }
5582    }
5583}
5584#[derive(bon::Builder)]
5585pub struct TextConstructor {
5586    text: TextToken,
5587}
5588impl TextConstructor {
5589    pub fn build(self) -> TextNode {
5590        let mut builder = CstBuilder::new();
5591        let text = builder.embed(self.text.builder);
5592        let node_id = builder.non_terminal(NonTerminalKind::Text, vec![text]);
5593        TextNode { node_id, builder }
5594    }
5595}
5596#[derive(bon::Builder)]
5597pub struct TextBindingConstructor {
5598    text_start: TextStartNode,
5599    text_binding_opt: TextBindingOptNode,
5600    text_binding_opt_0: TextBindingOpt0Node,
5601    text_binding_opt_1: TextBindingOpt1Node,
5602}
5603impl TextBindingConstructor {
5604    pub fn build(self) -> TextBindingNode {
5605        let mut builder = CstBuilder::new();
5606        let text_start = builder.embed(self.text_start.builder);
5607        let text_binding_opt = builder.embed(self.text_binding_opt.builder);
5608        let text_binding_opt_0 = builder.embed(self.text_binding_opt_0.builder);
5609        let text_binding_opt_1 = builder.embed(self.text_binding_opt_1.builder);
5610        let node_id = builder.non_terminal(
5611            NonTerminalKind::TextBinding,
5612            vec![
5613                text_start,
5614                text_binding_opt,
5615                text_binding_opt_0,
5616                text_binding_opt_1,
5617            ],
5618        );
5619        TextBindingNode { node_id, builder }
5620    }
5621}
5622#[derive(bon::Builder)]
5623pub struct TextBindingOptConstructor {
5624    ws: Option<WsNode>,
5625}
5626impl TextBindingOptConstructor {
5627    pub fn build(self) -> TextBindingOptNode {
5628        let mut builder = CstBuilder::new();
5629        let children = if let Some(child) = self.ws {
5630            vec![builder.embed(child.builder)]
5631        } else {
5632            Vec::<BuilderNodeId>::new()
5633        };
5634        let node_id = builder.non_terminal(NonTerminalKind::TextBindingOpt, children);
5635        TextBindingOptNode { node_id, builder }
5636    }
5637}
5638#[derive(bon::Builder)]
5639pub struct TextBindingOpt0Constructor {
5640    text: Option<TextNode>,
5641}
5642impl TextBindingOpt0Constructor {
5643    pub fn build(self) -> TextBindingOpt0Node {
5644        let mut builder = CstBuilder::new();
5645        let children = if let Some(child) = self.text {
5646            vec![builder.embed(child.builder)]
5647        } else {
5648            Vec::<BuilderNodeId>::new()
5649        };
5650        let node_id = builder.non_terminal(NonTerminalKind::TextBindingOpt0, children);
5651        TextBindingOpt0Node { node_id, builder }
5652    }
5653}
5654#[derive(bon::Builder)]
5655pub struct TextBindingOpt1Constructor {
5656    grammar_newline: Option<GrammarNewlineNode>,
5657}
5658impl TextBindingOpt1Constructor {
5659    pub fn build(self) -> TextBindingOpt1Node {
5660        let mut builder = CstBuilder::new();
5661        let children = if let Some(child) = self.grammar_newline {
5662            vec![builder.embed(child.builder)]
5663        } else {
5664            Vec::<BuilderNodeId>::new()
5665        };
5666        let node_id = builder.non_terminal(NonTerminalKind::TextBindingOpt1, children);
5667        TextBindingOpt1Node { node_id, builder }
5668    }
5669}
5670#[derive(bon::Builder)]
5671pub struct TextStartConstructor {
5672    text_start: TextStartToken,
5673}
5674impl TextStartConstructor {
5675    pub fn build(self) -> TextStartNode {
5676        let mut builder = CstBuilder::new();
5677        let text_start = builder.embed(self.text_start.builder);
5678        let node_id = builder.non_terminal(NonTerminalKind::TextStart, vec![text_start]);
5679        TextStartNode { node_id, builder }
5680    }
5681}
5682#[derive(bon::Builder)]
5683pub struct TrueConstructor {
5684    r#true: TrueToken,
5685}
5686impl TrueConstructor {
5687    pub fn build(self) -> TrueNode {
5688        let mut builder = CstBuilder::new();
5689        let r#true = builder.embed(self.r#true.builder);
5690        let node_id = builder.non_terminal(NonTerminalKind::True, vec![r#true]);
5691        TrueNode { node_id, builder }
5692    }
5693}
5694#[derive(bon::Builder)]
5695pub struct TupleConstructor {
5696    l_paren: LParenNode,
5697    tuple_opt: TupleOptNode,
5698    r_paren: RParenNode,
5699}
5700impl TupleConstructor {
5701    pub fn build(self) -> TupleNode {
5702        let mut builder = CstBuilder::new();
5703        let l_paren = builder.embed(self.l_paren.builder);
5704        let tuple_opt = builder.embed(self.tuple_opt.builder);
5705        let r_paren = builder.embed(self.r_paren.builder);
5706        let node_id =
5707            builder.non_terminal(NonTerminalKind::Tuple, vec![l_paren, tuple_opt, r_paren]);
5708        TupleNode { node_id, builder }
5709    }
5710}
5711#[derive(bon::Builder)]
5712pub struct TupleElementsConstructor {
5713    value: ValueNode,
5714    tuple_elements_opt: TupleElementsOptNode,
5715}
5716impl TupleElementsConstructor {
5717    pub fn build(self) -> TupleElementsNode {
5718        let mut builder = CstBuilder::new();
5719        let value = builder.embed(self.value.builder);
5720        let tuple_elements_opt = builder.embed(self.tuple_elements_opt.builder);
5721        let node_id = builder.non_terminal(
5722            NonTerminalKind::TupleElements,
5723            vec![value, tuple_elements_opt],
5724        );
5725        TupleElementsNode { node_id, builder }
5726    }
5727}
5728#[derive(bon::Builder)]
5729pub struct TupleElementsOptConstructor {
5730    tuple_elements_tail: Option<TupleElementsTailNode>,
5731}
5732impl TupleElementsOptConstructor {
5733    pub fn build(self) -> TupleElementsOptNode {
5734        let mut builder = CstBuilder::new();
5735        let children = if let Some(child) = self.tuple_elements_tail {
5736            vec![builder.embed(child.builder)]
5737        } else {
5738            Vec::<BuilderNodeId>::new()
5739        };
5740        let node_id = builder.non_terminal(NonTerminalKind::TupleElementsOpt, children);
5741        TupleElementsOptNode { node_id, builder }
5742    }
5743}
5744#[derive(bon::Builder)]
5745pub struct TupleElementsTailConstructor {
5746    comma: CommaNode,
5747    tuple_elements_tail_opt: TupleElementsTailOptNode,
5748}
5749impl TupleElementsTailConstructor {
5750    pub fn build(self) -> TupleElementsTailNode {
5751        let mut builder = CstBuilder::new();
5752        let comma = builder.embed(self.comma.builder);
5753        let tuple_elements_tail_opt = builder.embed(self.tuple_elements_tail_opt.builder);
5754        let node_id = builder.non_terminal(
5755            NonTerminalKind::TupleElementsTail,
5756            vec![comma, tuple_elements_tail_opt],
5757        );
5758        TupleElementsTailNode { node_id, builder }
5759    }
5760}
5761#[derive(bon::Builder)]
5762pub struct TupleElementsTailOptConstructor {
5763    tuple_elements: Option<TupleElementsNode>,
5764}
5765impl TupleElementsTailOptConstructor {
5766    pub fn build(self) -> TupleElementsTailOptNode {
5767        let mut builder = CstBuilder::new();
5768        let children = if let Some(child) = self.tuple_elements {
5769            vec![builder.embed(child.builder)]
5770        } else {
5771            Vec::<BuilderNodeId>::new()
5772        };
5773        let node_id = builder.non_terminal(NonTerminalKind::TupleElementsTailOpt, children);
5774        TupleElementsTailOptNode { node_id, builder }
5775    }
5776}
5777#[derive(bon::Builder)]
5778pub struct TupleIndexConstructor {
5779    hash: HashToken,
5780    integer: IntegerNode,
5781}
5782impl TupleIndexConstructor {
5783    pub fn build(self) -> TupleIndexNode {
5784        let mut builder = CstBuilder::new();
5785        let hash = builder.embed(self.hash.builder);
5786        let integer = builder.embed(self.integer.builder);
5787        let node_id = builder.non_terminal(NonTerminalKind::TupleIndex, vec![hash, integer]);
5788        TupleIndexNode { node_id, builder }
5789    }
5790}
5791#[derive(bon::Builder)]
5792pub struct TupleOptConstructor {
5793    tuple_elements: Option<TupleElementsNode>,
5794}
5795impl TupleOptConstructor {
5796    pub fn build(self) -> TupleOptNode {
5797        let mut builder = CstBuilder::new();
5798        let children = if let Some(child) = self.tuple_elements {
5799            vec![builder.embed(child.builder)]
5800        } else {
5801            Vec::<BuilderNodeId>::new()
5802        };
5803        let node_id = builder.non_terminal(NonTerminalKind::TupleOpt, children);
5804        TupleOptNode { node_id, builder }
5805    }
5806}
5807pub enum ValueConstructor {
5808    Object(ObjectNode),
5809    Array(ArrayNode),
5810    Tuple(TupleNode),
5811    Number(NumberNode),
5812    Boolean(BooleanNode),
5813    Null(NullNode),
5814    Strings(StringsNode),
5815    Hole(HoleNode),
5816    CodeBlock(CodeBlockNode),
5817    InlineCode(InlineCodeNode),
5818}
5819impl ValueConstructor {
5820    pub fn build(self) -> ValueNode {
5821        let mut builder = CstBuilder::new();
5822        let child_id = match self {
5823            Self::Object(node) => builder.embed(node.builder),
5824            Self::Array(node) => builder.embed(node.builder),
5825            Self::Tuple(node) => builder.embed(node.builder),
5826            Self::Number(node) => builder.embed(node.builder),
5827            Self::Boolean(node) => builder.embed(node.builder),
5828            Self::Null(node) => builder.embed(node.builder),
5829            Self::Strings(node) => builder.embed(node.builder),
5830            Self::Hole(node) => builder.embed(node.builder),
5831            Self::CodeBlock(node) => builder.embed(node.builder),
5832            Self::InlineCode(node) => builder.embed(node.builder),
5833        };
5834        let node_id = builder.non_terminal(NonTerminalKind::Value, vec![child_id]);
5835        ValueNode { node_id, builder }
5836    }
5837}
5838#[derive(bon::Builder)]
5839pub struct ValueBindingConstructor {
5840    bind: BindNode,
5841    value: ValueNode,
5842}
5843impl ValueBindingConstructor {
5844    pub fn build(self) -> ValueBindingNode {
5845        let mut builder = CstBuilder::new();
5846        let bind = builder.embed(self.bind.builder);
5847        let value = builder.embed(self.value.builder);
5848        let node_id = builder.non_terminal(NonTerminalKind::ValueBinding, vec![bind, value]);
5849        ValueBindingNode { node_id, builder }
5850    }
5851}
5852#[derive(bon::Builder)]
5853pub struct WsConstructor {
5854    ws: WsToken,
5855}
5856impl WsConstructor {
5857    pub fn build(self) -> WsNode {
5858        let mut builder = CstBuilder::new();
5859        let ws = builder.embed(self.ws.builder);
5860        let node_id = builder.non_terminal(NonTerminalKind::Ws, vec![ws]);
5861        WsNode { node_id, builder }
5862    }
5863}
5864#[derive(bon::Builder)]
5865pub struct RootConstructor {
5866    eure: EureNode,
5867}
5868impl RootConstructor {
5869    pub fn build(self) -> RootNode {
5870        let mut builder = CstBuilder::new();
5871        let eure = builder.embed(self.eure.builder);
5872        let node_id = builder.non_terminal(NonTerminalKind::Root, vec![eure]);
5873        RootNode { node_id, builder }
5874    }
5875}
5876pub mod terminals {
5877    use super::*;
5878    pub fn hash() -> HashToken {
5879        let mut builder = CstBuilder::new();
5880        let node_id = builder.terminal(TerminalKind::Hash, "");
5881        HashToken { node_id, builder }
5882    }
5883    pub fn map_bind() -> MapBindToken {
5884        let mut builder = CstBuilder::new();
5885        let node_id = builder.terminal(TerminalKind::MapBind, "");
5886        MapBindToken { node_id, builder }
5887    }
5888    pub fn integer(value: &str) -> IntegerToken {
5889        let mut builder = CstBuilder::new();
5890        let node_id = builder.terminal(TerminalKind::Integer, value);
5891        IntegerToken { node_id, builder }
5892    }
5893    pub fn float() -> FloatToken {
5894        let mut builder = CstBuilder::new();
5895        let node_id = builder.terminal(TerminalKind::Float, "");
5896        FloatToken { node_id, builder }
5897    }
5898    pub fn inf() -> InfToken {
5899        let mut builder = CstBuilder::new();
5900        let node_id = builder.terminal(TerminalKind::Inf, "");
5901        InfToken { node_id, builder }
5902    }
5903    pub fn na_n() -> NaNToken {
5904        let mut builder = CstBuilder::new();
5905        let node_id = builder.terminal(TerminalKind::NaN, "");
5906        NaNToken { node_id, builder }
5907    }
5908    pub fn r#true() -> TrueToken {
5909        let mut builder = CstBuilder::new();
5910        let node_id = builder.terminal(TerminalKind::True, "true");
5911        TrueToken { node_id, builder }
5912    }
5913    pub fn r#false() -> FalseToken {
5914        let mut builder = CstBuilder::new();
5915        let node_id = builder.terminal(TerminalKind::False, "false");
5916        FalseToken { node_id, builder }
5917    }
5918    pub fn null() -> NullToken {
5919        let mut builder = CstBuilder::new();
5920        let node_id = builder.terminal(TerminalKind::Null, "null");
5921        NullToken { node_id, builder }
5922    }
5923    pub fn hole() -> HoleToken {
5924        let mut builder = CstBuilder::new();
5925        let node_id = builder.terminal(TerminalKind::Hole, "!");
5926        HoleToken { node_id, builder }
5927    }
5928    pub fn str(value: &str) -> StrToken {
5929        let mut builder = CstBuilder::new();
5930        let node_id = builder.terminal(TerminalKind::Str, value);
5931        StrToken { node_id, builder }
5932    }
5933    pub fn lit_str() -> LitStrToken {
5934        let mut builder = CstBuilder::new();
5935        let node_id = builder.terminal(TerminalKind::LitStr, "");
5936        LitStrToken { node_id, builder }
5937    }
5938    pub fn text(value: &str) -> TextToken {
5939        let mut builder = CstBuilder::new();
5940        let node_id = builder.terminal(TerminalKind::Text, value);
5941        TextToken { node_id, builder }
5942    }
5943    pub fn inline_code_1() -> InlineCode1Token {
5944        let mut builder = CstBuilder::new();
5945        let node_id = builder.terminal(TerminalKind::InlineCode1, "");
5946        InlineCode1Token { node_id, builder }
5947    }
5948    pub fn lit_str_3_start() -> LitStr3StartToken {
5949        let mut builder = CstBuilder::new();
5950        let node_id = builder.terminal(TerminalKind::LitStr3Start, "");
5951        LitStr3StartToken { node_id, builder }
5952    }
5953    pub fn lit_str_2_start() -> LitStr2StartToken {
5954        let mut builder = CstBuilder::new();
5955        let node_id = builder.terminal(TerminalKind::LitStr2Start, "");
5956        LitStr2StartToken { node_id, builder }
5957    }
5958    pub fn lit_str_1_start() -> LitStr1StartToken {
5959        let mut builder = CstBuilder::new();
5960        let node_id = builder.terminal(TerminalKind::LitStr1Start, "");
5961        LitStr1StartToken { node_id, builder }
5962    }
5963    pub fn delim_code_start_3() -> DelimCodeStart3Token {
5964        let mut builder = CstBuilder::new();
5965        let node_id = builder.terminal(TerminalKind::DelimCodeStart3, "");
5966        DelimCodeStart3Token { node_id, builder }
5967    }
5968    pub fn delim_code_start_2() -> DelimCodeStart2Token {
5969        let mut builder = CstBuilder::new();
5970        let node_id = builder.terminal(TerminalKind::DelimCodeStart2, "");
5971        DelimCodeStart2Token { node_id, builder }
5972    }
5973    pub fn delim_code_start_1() -> DelimCodeStart1Token {
5974        let mut builder = CstBuilder::new();
5975        let node_id = builder.terminal(TerminalKind::DelimCodeStart1, "");
5976        DelimCodeStart1Token { node_id, builder }
5977    }
5978    pub fn code_block_start_3() -> CodeBlockStart3Token {
5979        let mut builder = CstBuilder::new();
5980        let node_id = builder.terminal(TerminalKind::CodeBlockStart3, "");
5981        CodeBlockStart3Token { node_id, builder }
5982    }
5983    pub fn code_block_start_4() -> CodeBlockStart4Token {
5984        let mut builder = CstBuilder::new();
5985        let node_id = builder.terminal(TerminalKind::CodeBlockStart4, "");
5986        CodeBlockStart4Token { node_id, builder }
5987    }
5988    pub fn code_block_start_5() -> CodeBlockStart5Token {
5989        let mut builder = CstBuilder::new();
5990        let node_id = builder.terminal(TerminalKind::CodeBlockStart5, "");
5991        CodeBlockStart5Token { node_id, builder }
5992    }
5993    pub fn code_block_start_6() -> CodeBlockStart6Token {
5994        let mut builder = CstBuilder::new();
5995        let node_id = builder.terminal(TerminalKind::CodeBlockStart6, "");
5996        CodeBlockStart6Token { node_id, builder }
5997    }
5998    pub fn code_block_end_3() -> CodeBlockEnd3Token {
5999        let mut builder = CstBuilder::new();
6000        let node_id = builder.terminal(TerminalKind::CodeBlockEnd3, "");
6001        CodeBlockEnd3Token { node_id, builder }
6002    }
6003    pub fn backtick_2() -> Backtick2Token {
6004        let mut builder = CstBuilder::new();
6005        let node_id = builder.terminal(TerminalKind::Backtick2, "");
6006        Backtick2Token { node_id, builder }
6007    }
6008    pub fn code_block_end_4() -> CodeBlockEnd4Token {
6009        let mut builder = CstBuilder::new();
6010        let node_id = builder.terminal(TerminalKind::CodeBlockEnd4, "");
6011        CodeBlockEnd4Token { node_id, builder }
6012    }
6013    pub fn backtick_3() -> Backtick3Token {
6014        let mut builder = CstBuilder::new();
6015        let node_id = builder.terminal(TerminalKind::Backtick3, "");
6016        Backtick3Token { node_id, builder }
6017    }
6018    pub fn code_block_end_5() -> CodeBlockEnd5Token {
6019        let mut builder = CstBuilder::new();
6020        let node_id = builder.terminal(TerminalKind::CodeBlockEnd5, "");
6021        CodeBlockEnd5Token { node_id, builder }
6022    }
6023    pub fn backtick_4() -> Backtick4Token {
6024        let mut builder = CstBuilder::new();
6025        let node_id = builder.terminal(TerminalKind::Backtick4, "");
6026        Backtick4Token { node_id, builder }
6027    }
6028    pub fn code_block_end_6() -> CodeBlockEnd6Token {
6029        let mut builder = CstBuilder::new();
6030        let node_id = builder.terminal(TerminalKind::CodeBlockEnd6, "");
6031        CodeBlockEnd6Token { node_id, builder }
6032    }
6033    pub fn backtick_5() -> Backtick5Token {
6034        let mut builder = CstBuilder::new();
6035        let node_id = builder.terminal(TerminalKind::Backtick5, "");
6036        Backtick5Token { node_id, builder }
6037    }
6038    pub fn no_backtick() -> NoBacktickToken {
6039        let mut builder = CstBuilder::new();
6040        let node_id = builder.terminal(TerminalKind::NoBacktick, "");
6041        NoBacktickToken { node_id, builder }
6042    }
6043    pub fn lit_str_3_end() -> LitStr3EndToken {
6044        let mut builder = CstBuilder::new();
6045        let node_id = builder.terminal(TerminalKind::LitStr3End, "");
6046        LitStr3EndToken { node_id, builder }
6047    }
6048    pub fn lit_str_2_end() -> LitStr2EndToken {
6049        let mut builder = CstBuilder::new();
6050        let node_id = builder.terminal(TerminalKind::LitStr2End, "");
6051        LitStr2EndToken { node_id, builder }
6052    }
6053    pub fn lit_str_1_end() -> LitStr1EndToken {
6054        let mut builder = CstBuilder::new();
6055        let node_id = builder.terminal(TerminalKind::LitStr1End, "");
6056        LitStr1EndToken { node_id, builder }
6057    }
6058    pub fn s_quote() -> SQuoteToken {
6059        let mut builder = CstBuilder::new();
6060        let node_id = builder.terminal(TerminalKind::SQuote, "");
6061        SQuoteToken { node_id, builder }
6062    }
6063    pub fn no_s_quote() -> NoSQuoteToken {
6064        let mut builder = CstBuilder::new();
6065        let node_id = builder.terminal(TerminalKind::NoSQuote, "");
6066        NoSQuoteToken { node_id, builder }
6067    }
6068    pub fn delim_code_end_3() -> DelimCodeEnd3Token {
6069        let mut builder = CstBuilder::new();
6070        let node_id = builder.terminal(TerminalKind::DelimCodeEnd3, "");
6071        DelimCodeEnd3Token { node_id, builder }
6072    }
6073    pub fn delim_code_end_2() -> DelimCodeEnd2Token {
6074        let mut builder = CstBuilder::new();
6075        let node_id = builder.terminal(TerminalKind::DelimCodeEnd2, "");
6076        DelimCodeEnd2Token { node_id, builder }
6077    }
6078    pub fn delim_code_end_1() -> DelimCodeEnd1Token {
6079        let mut builder = CstBuilder::new();
6080        let node_id = builder.terminal(TerminalKind::DelimCodeEnd1, "");
6081        DelimCodeEnd1Token { node_id, builder }
6082    }
6083    pub fn backtick_delim() -> BacktickDelimToken {
6084        let mut builder = CstBuilder::new();
6085        let node_id = builder.terminal(TerminalKind::BacktickDelim, "");
6086        BacktickDelimToken { node_id, builder }
6087    }
6088    pub fn grammar_newline() -> GrammarNewlineToken {
6089        let mut builder = CstBuilder::new();
6090        let node_id = builder.terminal(TerminalKind::GrammarNewline, "\n");
6091        GrammarNewlineToken { node_id, builder }
6092    }
6093    pub fn ws() -> WsToken {
6094        let mut builder = CstBuilder::new();
6095        let node_id = builder.terminal(TerminalKind::Ws, " ");
6096        WsToken { node_id, builder }
6097    }
6098    pub fn at() -> AtToken {
6099        let mut builder = CstBuilder::new();
6100        let node_id = builder.terminal(TerminalKind::At, "@");
6101        AtToken { node_id, builder }
6102    }
6103    pub fn dollar() -> DollarToken {
6104        let mut builder = CstBuilder::new();
6105        let node_id = builder.terminal(TerminalKind::Dollar, "$");
6106        DollarToken { node_id, builder }
6107    }
6108    pub fn dot() -> DotToken {
6109        let mut builder = CstBuilder::new();
6110        let node_id = builder.terminal(TerminalKind::Dot, ".");
6111        DotToken { node_id, builder }
6112    }
6113    pub fn l_brace() -> LBraceToken {
6114        let mut builder = CstBuilder::new();
6115        let node_id = builder.terminal(TerminalKind::LBrace, "{");
6116        LBraceToken { node_id, builder }
6117    }
6118    pub fn r_brace() -> RBraceToken {
6119        let mut builder = CstBuilder::new();
6120        let node_id = builder.terminal(TerminalKind::RBrace, "}");
6121        RBraceToken { node_id, builder }
6122    }
6123    pub fn l_bracket() -> LBracketToken {
6124        let mut builder = CstBuilder::new();
6125        let node_id = builder.terminal(TerminalKind::LBracket, "[");
6126        LBracketToken { node_id, builder }
6127    }
6128    pub fn r_bracket() -> RBracketToken {
6129        let mut builder = CstBuilder::new();
6130        let node_id = builder.terminal(TerminalKind::RBracket, "]");
6131        RBracketToken { node_id, builder }
6132    }
6133    pub fn l_paren() -> LParenToken {
6134        let mut builder = CstBuilder::new();
6135        let node_id = builder.terminal(TerminalKind::LParen, "");
6136        LParenToken { node_id, builder }
6137    }
6138    pub fn r_paren() -> RParenToken {
6139        let mut builder = CstBuilder::new();
6140        let node_id = builder.terminal(TerminalKind::RParen, "");
6141        RParenToken { node_id, builder }
6142    }
6143    pub fn bind() -> BindToken {
6144        let mut builder = CstBuilder::new();
6145        let node_id = builder.terminal(TerminalKind::Bind, "=");
6146        BindToken { node_id, builder }
6147    }
6148    pub fn comma() -> CommaToken {
6149        let mut builder = CstBuilder::new();
6150        let node_id = builder.terminal(TerminalKind::Comma, ",");
6151        CommaToken { node_id, builder }
6152    }
6153    pub fn esc() -> EscToken {
6154        let mut builder = CstBuilder::new();
6155        let node_id = builder.terminal(TerminalKind::Esc, "\\\\");
6156        EscToken { node_id, builder }
6157    }
6158    pub fn text_start() -> TextStartToken {
6159        let mut builder = CstBuilder::new();
6160        let node_id = builder.terminal(TerminalKind::TextStart, "");
6161        TextStartToken { node_id, builder }
6162    }
6163    pub fn ident(name: &str) -> IdentToken {
6164        let mut builder = CstBuilder::new();
6165        let node_id = builder.terminal(TerminalKind::Ident, name);
6166        IdentToken { node_id, builder }
6167    }
6168}