diff --git a/.cargo/config.toml b/.cargo/config.toml
index 7627a3b074d..d8abad084ce 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -7,6 +7,7 @@ codegen-bindings = "run -p xtask_codegen --features schema -- bindings"
 codegen-configuration = "run -p xtask_codegen --features configuration -- configuration"
 codegen-schema = "run -p xtask_codegen --features schema -- schema"
 codegen-website = "run -p xtask_codegen --features website -- website"
+codemod = "run -p rome_v8 --example codemod --"
 contributors = "run -p xtask_contributors --"
 coverage = "run -p xtask_coverage --profile=release-with-debug --"
 documentation = """
diff --git a/Cargo.lock b/Cargo.lock
index 1e910542dc3..6d26eb90194 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -167,7 +167,7 @@ checksum = "ac88f5e10b620a207805c5a6f538a7777dc55e5469bbc0eec27e2bf75d5ee0f6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.15",
+ "syn 2.0.28",
 ]
 
 [[package]]
@@ -324,6 +324,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "convert_case"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+
 [[package]]
 name = "countme"
 version = "3.0.1"
@@ -471,6 +477,19 @@ dependencies = [
  "parking_lot_core",
 ]
 
+[[package]]
+name = "derive_more"
+version = "0.99.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "dhat"
 version = "0.3.2"
@@ -636,6 +655,16 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
 
+[[package]]
+name = "fslock"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57eafdd0c16f57161105ae1b98a1238f97645f2f588438b2949c99a2af9616bf"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "fst"
 version = "0.4.7"
@@ -1168,6 +1197,16 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54"
 
+[[package]]
+name = "nom"
+version = "5.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08959a387a676302eebf4ddbcbc611da04285579f76f88ee0506c63b1a61dd4b"
+dependencies = [
+ "memchr",
+ "version_check",
+]
+
 [[package]]
 name = "nu-ansi-term"
 version = "0.46.0"
@@ -1178,6 +1217,28 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "num-bigint"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.15"
@@ -1350,6 +1411,16 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
+[[package]]
+name = "prettyplease"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c8646e95016a7a6c4adea95bafa8a16baab64b583356217f2c85db4a39d9a86"
+dependencies = [
+ "proc-macro2",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -1885,6 +1956,17 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "rome_idl"
+version = "0.1.0"
+dependencies = [
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "weedle",
+]
+
 [[package]]
 name = "rome_js_analyze"
 version = "0.0.0"
@@ -2265,6 +2347,27 @@ dependencies = [
  "static_assertions",
 ]
 
+[[package]]
+name = "rome_v8"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "bpaf",
+ "crossbeam",
+ "rome_console",
+ "rome_diagnostics",
+ "rome_fs",
+ "rome_idl",
+ "rome_js_factory",
+ "rome_js_parser",
+ "rome_js_syntax",
+ "rome_rowan",
+ "rome_service",
+ "serde",
+ "serde_v8",
+ "v8",
+]
+
 [[package]]
 name = "rome_wasm"
 version = "0.0.0"
@@ -2306,6 +2409,15 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver",
+]
+
 [[package]]
 name = "rustix"
 version = "0.36.9"
@@ -2400,11 +2512,17 @@ dependencies = [
  "untrusted",
 ]
 
+[[package]]
+name = "semver"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0293b4b29daaf487284529cc2f5675b8e57c61f70167ba415a463651fd6a918"
+
 [[package]]
 name = "serde"
-version = "1.0.164"
+version = "1.0.179"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e8c8cf938e98f769bc164923b06dce91cea1751522f46f8466461af04c9027d"
+checksum = "0a5bf42b8d227d4abf38a1ddb08602e229108a517cd4e5bb28f9c7eaafdce5c0"
 dependencies = [
  "serde_derive",
 ]
@@ -2420,15 +2538,24 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "serde_bytes"
+version = "0.11.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab33ec92f677585af6d88c65593ae2375adde54efdbf16d597f2cbc7a6d368ff"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "serde_derive"
-version = "1.0.164"
+version = "1.0.179"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9735b638ccc51c28bf6914d90a2e9725b377144fc612c49a611fddd1b631d68"
+checksum = "741e124f5485c7e60c03b043f79f320bff3527f4bbf12cf3831750dc46a0ec2c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.15",
+ "syn 2.0.28",
 ]
 
 [[package]]
@@ -2473,6 +2600,22 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_v8"
+version = "0.108.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a1a26c89d56d8607d220c639e971e3e3901138fcc5dd0f619cee0868e1cc89e"
+dependencies = [
+ "bytes",
+ "derive_more",
+ "num-bigint",
+ "serde",
+ "serde_bytes",
+ "smallvec",
+ "thiserror",
+ "v8",
+]
+
 [[package]]
 name = "serde_yaml"
 version = "0.9.19"
@@ -2583,9 +2726,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.15"
+version = "2.0.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a34fcf3e8b60f57e6a14301a2e916d323af98b0ea63c599441eec8558660c822"
+checksum = "04361975b3f5e348b2189d8dc55bc942f278b2d482a6a0365de5bdd62d351567"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2642,6 +2785,26 @@ version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
 
+[[package]]
+name = "thiserror"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "611040a08a0439f8248d1990b111c95baa9c704c805fa1f62104b39655fd7f90"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "090198534930841fab3a5d1bb637cde49e339654e606195f8d9c76eeb081dc96"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.28",
+]
+
 [[package]]
 name = "thousands"
 version = "0.2.0"
@@ -3054,6 +3217,18 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5190c9442dcdaf0ddd50f37420417d219ae5261bbf5db120d0f9bab996c9cba1"
 
+[[package]]
+name = "v8"
+version = "0.74.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2eedac634b8dd39b889c5b62349cbc55913780226239166435c5cf66771792ea"
+dependencies = [
+ "bitflags 1.3.2",
+ "fslock",
+ "once_cell",
+ "which",
+]
+
 [[package]]
 name = "valuable"
 version = "0.1.0"
@@ -3195,6 +3370,26 @@ dependencies = [
  "webpki",
 ]
 
+[[package]]
+name = "weedle"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "610950904727748ca09682e857f0d6d6437f0ca862f32f9229edba8cec8b2635"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "which"
+version = "4.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2441c784c52b289a054b7201fc93253e288f094e2f4be9058343127c4226a269"
+dependencies = [
+ "either",
+ "libc",
+ "once_cell",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
diff --git a/Cargo.toml b/Cargo.toml
index 5e86ca561d9..7ab8743b649 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -83,6 +83,7 @@ serde             = { version = "1.0.163", features = ["derive"], default-featur
 serde_json        = "1.0.96"
 smallvec          = { version = "1.10.0", features = ["union", "const_new"] }
 tracing           = { version = "0.1.37", default-features = false, features = ["std"] }
+crossbeam = "0.8.2"
 # pinning to version 1.18 to avoid multiple versions of windows-sys as dependency
 tokio = { version = "~1.18.5" }
 
diff --git a/crates/rome_cli/Cargo.toml b/crates/rome_cli/Cargo.toml
index d6d7b152201..570b87dead3 100644
--- a/crates/rome_cli/Cargo.toml
+++ b/crates/rome_cli/Cargo.toml
@@ -14,7 +14,7 @@ path = "src/main.rs"
 [dependencies]
 anyhow              = "1.0.52"
 bpaf                = { workspace = true }
-crossbeam           = "0.8.1"
+crossbeam           = { workspace = true }
 dashmap             = { workspace = true }
 hdrhistogram        = { version = "7.5.0", default-features = false }
 indexmap            = { workspace = true }
diff --git a/crates/rome_fs/Cargo.toml b/crates/rome_fs/Cargo.toml
index 0b65ad08a6b..7e64e14f4d7 100644
--- a/crates/rome_fs/Cargo.toml
+++ b/crates/rome_fs/Cargo.toml
@@ -9,7 +9,7 @@ version              = "0.0.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-crossbeam        = "0.8.1"
+crossbeam        = { workspace = true }
 indexmap         = { workspace = true }
 parking_lot      = { version = "0.12.0", features = ["arc_lock"] }
 rayon            = "1.5.1"
diff --git a/crates/rome_fs/src/fs.rs b/crates/rome_fs/src/fs.rs
index b0d53993408..9715f58d074 100644
--- a/crates/rome_fs/src/fs.rs
+++ b/crates/rome_fs/src/fs.rs
@@ -216,6 +216,11 @@ pub trait FileSystemExt: FileSystem {
         )
     }
 
+    /// Opens a file with read options
+    fn read(&self, path: &Path) -> io::Result<Box<dyn File>> {
+        self.open_with_options(path, OpenOptions::default().read(true))
+    }
+
     /// Opens a file with the `read`, `write` and `create_new` options
     ///
     /// Equivalent to [std::fs::File::create_new]
@@ -230,7 +235,7 @@ pub trait FileSystemExt: FileSystem {
     }
 }
 
-impl<T: ?Sized> FileSystemExt for T where T: FileSystem {}
+impl<T: FileSystem + ?Sized> FileSystemExt for T {}
 
 type BoxedTraversal<'fs, 'scope> = Box<dyn FnOnce(&dyn TraversalScope<'scope>) + Send + 'fs>;
 
diff --git a/crates/rome_idl/Cargo.toml b/crates/rome_idl/Cargo.toml
new file mode 100644
index 00000000000..5dfa38f1eeb
--- /dev/null
+++ b/crates/rome_idl/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+edition = "2021"
+name    = "rome_idl"
+version = "0.1.0"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+prettyplease = "0.1.21"
+proc-macro2  = "1.0.43"
+quote        = "1.0.14"
+syn          = "1.0.90"
+weedle       = "0.12.0"
diff --git a/crates/rome_idl/src/lib.rs b/crates/rome_idl/src/lib.rs
new file mode 100644
index 00000000000..748f27cff1d
--- /dev/null
+++ b/crates/rome_idl/src/lib.rs
@@ -0,0 +1,858 @@
+use std::collections::{btree_map, BTreeMap};
+
+use prettyplease::unparse;
+use proc_macro2::{Ident, TokenStream};
+use quote::{format_ident, quote};
+use syn::{parse_quote, parse_str};
+use weedle::{
+    argument::Argument,
+    attribute::{ExtendedAttribute, ExtendedAttributeList, IdentifierOrString},
+    common::{Bracketed, Identifier, Punctuated},
+    interface::{
+        AttributeInterfaceMember, ConstructorInterfaceMember, InterfaceMember,
+        IterableInterfaceMember, OperationInterfaceMember, StringifierOrStatic,
+    },
+    literal::DefaultValue,
+    namespace::{AttributeNamespaceMember, NamespaceMember, OperationNamespaceMember},
+    parse,
+    term::Comma,
+    types::{FloatingPointType, IntegerType, MayBeNull, NonAnyType, ReturnType, SingleType, Type},
+    Definition, InterfaceDefinition, NamespaceDefinition,
+};
+
+pub fn generate(source: &str) -> String {
+    let definitions = parse(source).expect("failed to parse IDL file");
+
+    let definitions = DefinitionsMap::new(definitions);
+
+    let mut stmts = Vec::new();
+    let mut ops = Vec::new();
+
+    for (_, definition) in definitions.iter() {
+        handle_definition(&definitions, &mut ops, &mut stmts, definition);
+    }
+
+    unparse(&parse_quote! {
+        use crate::convert::{FromV8, ToV8};
+        use super::TemplateRegistry;
+
+        pub(super) fn register_interfaces(scope: &mut v8::HandleScope<'_, ()>, global: v8::Local<'_, v8::ObjectTemplate>, registry: &mut TemplateRegistry) {
+            #( #stmts )*
+        }
+
+        #( #ops )*
+    })
+}
+
+fn handle_definition(
+    definitions: &DefinitionsMap,
+    ops: &mut Vec<TokenStream>,
+    stmts: &mut Vec<TokenStream>,
+    definition: &Definition,
+) {
+    match definition {
+        Definition::Typedef(_) | Definition::Enum(_) => {}
+        Definition::Interface(interface) => handle_class(definitions, ops, stmts, interface),
+        Definition::Namespace(namespace) => handle_class(definitions, ops, stmts, namespace),
+        _ => unimplemented!("definitions of this type are not implemented yet: {definition:?}"),
+    }
+}
+
+trait ClassDefinition<'a> {
+    type Member: ClassMember<'a> + 'a;
+
+    const IS_NAMESPACE: bool;
+
+    fn attributes(&self) -> Option<&ExtendedAttributeList>;
+    fn identifier(&self) -> &str;
+    fn members(&self) -> &[Self::Member];
+}
+
+impl<'a> ClassDefinition<'a> for InterfaceDefinition<'a> {
+    type Member = InterfaceMember<'a>;
+
+    const IS_NAMESPACE: bool = false;
+
+    fn attributes(&self) -> Option<&ExtendedAttributeList> {
+        self.attributes.as_ref()
+    }
+
+    fn identifier(&self) -> &str {
+        self.identifier.0
+    }
+
+    fn members(&self) -> &[Self::Member] {
+        &self.members.body
+    }
+}
+
+impl<'a> ClassDefinition<'a> for NamespaceDefinition<'a> {
+    type Member = NamespaceMember<'a>;
+
+    const IS_NAMESPACE: bool = true;
+
+    fn attributes(&self) -> Option<&ExtendedAttributeList> {
+        self.attributes.as_ref()
+    }
+
+    fn identifier(&self) -> &str {
+        self.identifier.0
+    }
+
+    fn members(&self) -> &[Self::Member] {
+        &self.members.body
+    }
+}
+
+fn handle_class<'a, D: ClassDefinition<'a>>(
+    definitions: &DefinitionsMap,
+    ops: &mut Vec<TokenStream>,
+    stmts: &mut Vec<TokenStream>,
+    definition: &'a D,
+) {
+    let mut is_exposed = false;
+
+    if let Some(attrs) = definition.attributes() {
+        for attr in &attrs.body.list {
+            if let ExtendedAttribute::Ident(attr) = attr {
+                if attr.lhs_identifier.0 == "Exposed" {
+                    is_exposed = true;
+                }
+            }
+        }
+    }
+
+    let interface_name = definition.identifier();
+    let interface_type = find_rust_type(definition);
+
+    let mut constructor = None;
+    let mut members = Vec::new();
+
+    for member in definition.members() {
+        handle_member(
+            definitions,
+            ops,
+            &mut constructor,
+            &mut members,
+            interface_name,
+            &interface_type,
+            member,
+        );
+    }
+
+    let builder = if D::IS_NAMESPACE {
+        quote! { build_namespace(scope, global, #interface_name) }
+    } else if is_exposed {
+        if let Some(constructor) = constructor {
+            quote! { build_class_with_constructor::<#interface_type>(scope, global, #interface_name, #constructor) }
+        } else {
+            quote! { build_class::<#interface_type>(scope, global, #interface_name) }
+        }
+    } else {
+        quote! { build_interface::<#interface_type>(scope) }
+    };
+
+    let maybe_finish = if !D::IS_NAMESPACE {
+        quote! { .finish(scope) }
+    } else {
+        quote!()
+    };
+
+    stmts.push(quote! {
+        registry.#builder
+            #( #members )*
+            #maybe_finish;
+    });
+}
+
+enum MemberKind<'a, M: ClassMember<'a> + ?Sized> {
+    Operation(&'a M::Operation),
+    Iterable(&'a IterableInterfaceMember<'a>),
+    Attribute(&'a M::Attribute),
+    Constructor(&'a ConstructorInterfaceMember<'a>),
+    Other,
+}
+
+trait ClassMember<'a> {
+    type Operation: ClassOperation + 'a;
+    type Attribute;
+
+    fn kind(&'a self) -> MemberKind<'a, Self>;
+}
+
+impl<'a> ClassMember<'a> for InterfaceMember<'a> {
+    type Operation = OperationInterfaceMember<'a>;
+    type Attribute = AttributeInterfaceMember<'a>;
+
+    fn kind(&'a self) -> MemberKind<'a, Self> {
+        match self {
+            Self::Operation(op) => MemberKind::Operation(op),
+            Self::Iterable(iter) => MemberKind::Iterable(iter),
+            Self::Attribute(op) => MemberKind::Attribute(op),
+            Self::Constructor(op) => MemberKind::Constructor(op),
+            _ => MemberKind::Other,
+        }
+    }
+}
+
+impl<'a> ClassMember<'a> for NamespaceMember<'a> {
+    type Operation = OperationNamespaceMember<'a>;
+    type Attribute = AttributeNamespaceMember<'a>;
+
+    fn kind(&'a self) -> MemberKind<'a, Self> {
+        match self {
+            Self::Operation(op) => MemberKind::Operation(op),
+            Self::Attribute(op) => MemberKind::Attribute(op),
+        }
+    }
+}
+
+trait ClassOperation {
+    const IS_NAMESPACE: bool;
+
+    fn attributes(&self) -> Option<&ExtendedAttributeList>;
+    fn identifier(&self) -> Option<&str>;
+    fn modifier(&self) -> Option<&StringifierOrStatic>;
+    fn args(&self) -> &[Argument];
+    fn return_type(&self) -> &ReturnType;
+}
+
+impl ClassOperation for OperationInterfaceMember<'_> {
+    const IS_NAMESPACE: bool = false;
+
+    fn attributes(&self) -> Option<&ExtendedAttributeList> {
+        self.attributes.as_ref()
+    }
+
+    fn identifier(&self) -> Option<&str> {
+        self.identifier.as_ref().map(|id| id.0)
+    }
+
+    fn modifier(&self) -> Option<&StringifierOrStatic> {
+        self.modifier.as_ref()
+    }
+
+    fn args(&self) -> &[Argument] {
+        &self.args.body.list
+    }
+
+    fn return_type(&self) -> &ReturnType {
+        &self.return_type
+    }
+}
+
+impl ClassOperation for OperationNamespaceMember<'_> {
+    const IS_NAMESPACE: bool = true;
+
+    fn attributes(&self) -> Option<&ExtendedAttributeList> {
+        self.attributes.as_ref()
+    }
+
+    fn identifier(&self) -> Option<&str> {
+        self.identifier.as_ref().map(|id| id.0)
+    }
+
+    fn modifier(&self) -> Option<&StringifierOrStatic> {
+        None
+    }
+
+    fn args(&self) -> &[Argument] {
+        &self.args.body.list
+    }
+
+    fn return_type(&self) -> &ReturnType {
+        &self.return_type
+    }
+}
+
+fn handle_member<'a, M: ClassMember<'a>>(
+    definitions: &DefinitionsMap,
+    ops: &mut Vec<TokenStream>,
+    constructor_id: &mut Option<Ident>,
+    members: &mut Vec<TokenStream>,
+    interface_name: &str,
+    interface_type: &syn::Type,
+    member: &'a M,
+) {
+    match member.kind() {
+        MemberKind::Operation(operation) => handle_operation(
+            definitions,
+            ops,
+            members,
+            interface_name,
+            interface_type,
+            operation,
+        ),
+
+        MemberKind::Constructor(member) => handle_constructor(
+            definitions,
+            ops,
+            constructor_id,
+            interface_name,
+            interface_type,
+            member,
+        ),
+
+        MemberKind::Iterable(IterableInterfaceMember::Single(_)) => {
+            members.push(quote! {
+                .iterable(scope, ToV8::to_v8)
+            });
+        }
+        MemberKind::Iterable(IterableInterfaceMember::Double(_)) => {
+            unimplemented!("key-value iterables are not implemented yet")
+        }
+
+        // Ignore for now
+        MemberKind::Attribute(_) => {}
+
+        MemberKind::Other => unimplemented!("non-operation members are not implemented yet"),
+    }
+}
+
+fn handle_operation<O: ClassOperation>(
+    definitions: &DefinitionsMap,
+    ops: &mut Vec<TokenStream>,
+    members: &mut Vec<TokenStream>,
+    interface_name: &str,
+    interface_type: &syn::Type,
+    operation: &O,
+) {
+    let method_name = match operation.identifier() {
+        Some(id) => id,
+        None => unimplemented!("special operations are not implemented yet"),
+    };
+
+    let mut is_static = false;
+    let mut has_custom = false;
+    let mut has_custom_binding = false;
+    let mut is_cloned_this = false;
+    let mut is_mutable_this = false;
+    let mut is_cloned_result = false;
+
+    if let Some(modifier) = operation.modifier() {
+        match modifier {
+            StringifierOrStatic::Stringifier(_) => {}
+            StringifierOrStatic::Static(_) => {
+                is_static = true;
+            }
+        }
+    }
+
+    if let Some(attrs) = operation.attributes() {
+        for attr in &attrs.body.list {
+            if let ExtendedAttribute::NoArgs(attr) = attr {
+                match (attr.0).0 {
+                    "Custom" => {
+                        has_custom = true;
+                    }
+                    "CustomBinding" => {
+                        has_custom_binding = true;
+                    }
+                    "ClonedThis" => {
+                        is_cloned_this = true;
+                    }
+                    "MutableThis" => {
+                        is_mutable_this = true;
+                    }
+                    "ClonedResult" => {
+                        is_cloned_result = true;
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+
+    let op_id = format_ident!("{interface_name}_{method_name}");
+    let method_id = format_ident!("{method_name}");
+
+    if !has_custom_binding {
+        let load_this = if !O::IS_NAMESPACE && !is_static {
+            let mut load_this = quote! {
+                let this = args.this().into();
+            };
+
+            load_this = if is_mutable_this {
+                quote! {
+                    #load_this
+                    let mut this = <std::cell::RefMut<#interface_type> as FromV8>::from_v8(scope, this).unwrap();
+                }
+            } else {
+                quote! {
+                    #load_this
+                    let this = <std::cell::Ref<#interface_type> as FromV8>::from_v8(scope, this).unwrap();
+                }
+            };
+
+            if is_cloned_this {
+                load_this = quote! {
+                    #load_this
+                    let this = this.clone();
+                };
+            }
+
+            load_this
+        } else {
+            quote!()
+        };
+
+        let mut arg_idents = Vec::new();
+        let mut arg_bindings = Vec::new();
+
+        for (arg_index, arg) in operation.args().iter().enumerate() {
+            handle_argument(
+                definitions,
+                &mut arg_idents,
+                &mut arg_bindings,
+                arg_index,
+                arg,
+            );
+        }
+
+        let call_method = if has_custom {
+            let custom_id = format_ident!("{method_name}_impl");
+            quote! {
+                #custom_id( #( #arg_idents ),* )
+            }
+        } else if O::IS_NAMESPACE || is_static {
+            quote! {
+                #interface_type::#method_id( #( #arg_idents ),* )
+            }
+        } else {
+            quote! {
+                this.#method_id( #( #arg_idents ),* )
+            }
+        };
+
+        let (result_id, write_result) = match operation.return_type() {
+            ReturnType::Undefined(_) => (quote! { _result }, quote! { #call_method; }),
+            ReturnType::Type(ty) => {
+                let write_result = match definitions.resolve_type(ty) {
+                    TypeKind::Interface { optional, .. } => {
+                        let mut set_result = quote! {
+                            let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+                            result.set(res);
+                        };
+
+                        if is_cloned_result {
+                            set_result = quote! {
+                                let res = res.clone();
+                                #set_result
+                            };
+                        };
+
+                        if optional {
+                            quote! {
+                                if let Some(res) = #call_method {
+                                    #set_result
+                                }
+                            }
+                        } else {
+                            quote! {
+                                let res = #call_method;
+                                #set_result
+                            }
+                        }
+                    }
+                    TypeKind::Value { .. } => quote! {
+                        let res = #call_method;
+                        let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+                        result.set(res);
+                    },
+                };
+
+                (quote! { mut result }, write_result)
+            }
+        };
+
+        ops.push(quote! {
+            #[allow(non_snake_case)]
+            fn #op_id<'s>(scope: &mut v8::HandleScope<'s>, args: v8::FunctionCallbackArguments<'s>, #result_id: v8::ReturnValue) {
+                #load_this
+                #( #arg_bindings )*
+                #write_result
+            }
+        });
+    }
+
+    members.push(if is_static {
+        quote! {
+            .method_static(scope, #method_name, #op_id)
+        }
+    } else {
+        quote! {
+            .method(scope, #method_name, #op_id)
+        }
+    });
+}
+
+fn handle_constructor(
+    definitions: &DefinitionsMap,
+    ops: &mut Vec<TokenStream>,
+    constructor_id: &mut Option<Ident>,
+    interface_name: &str,
+    interface_type: &syn::Type,
+    constructor: &ConstructorInterfaceMember,
+) {
+    let mut has_custom = false;
+    let mut has_custom_binding = false;
+
+    if let Some(attrs) = &constructor.attributes {
+        for attr in &attrs.body.list {
+            if let ExtendedAttribute::NoArgs(attr) = attr {
+                match (attr.0).0 {
+                    "Custom" => {
+                        has_custom = true;
+                    }
+                    "CustomBinding" => {
+                        has_custom_binding = true;
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+
+    let op_id = format_ident!("{interface_name}_constructor");
+
+    if !has_custom_binding {
+        let mut arg_idents = Vec::new();
+        let mut arg_bindings = Vec::new();
+
+        for (arg_index, arg) in constructor.args.body.list.iter().enumerate() {
+            handle_argument(
+                definitions,
+                &mut arg_idents,
+                &mut arg_bindings,
+                arg_index,
+                arg,
+            );
+        }
+
+        let call_method = if has_custom {
+            let custom_id = format_ident!("{interface_name}_constructor_impl");
+            quote! {
+                #custom_id( #( #arg_idents ),* )
+            }
+        } else {
+            quote! {
+                #interface_type::new( #( #arg_idents ),* )
+            }
+        };
+
+        ops.push(quote! {
+            #[allow(non_snake_case)]
+            fn #op_id<'s>(scope: &mut v8::HandleScope<'s>, args: v8::FunctionCallbackArguments<'s>, _res: v8::ReturnValue) {
+                #( #arg_bindings )*
+                let res = #call_method;
+                crate::registry::store_native(scope, args.this(), res);
+            }
+        });
+    }
+
+    *constructor_id = Some(op_id);
+}
+
+fn handle_argument(
+    definitions: &DefinitionsMap,
+    arg_idents: &mut Vec<TokenStream>,
+    arg_bindings: &mut Vec<TokenStream>,
+    arg_index: usize,
+    arg: &Argument,
+) {
+    let arg = match arg {
+        Argument::Single(arg) => arg,
+        Argument::Variadic(_) => unimplemented!("variadic arguments"),
+    };
+
+    let mut is_cloned = false;
+    let mut is_by_ref = false;
+
+    for attr in arg.attributes.iter().flat_map(|item| &item.body.list) {
+        if let ExtendedAttribute::NoArgs(attr) = attr {
+            match (attr.0).0 {
+                "Cloned" => {
+                    is_cloned = true;
+                }
+                "ByRef" => {
+                    is_by_ref = true;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    let arg_ident = format_ident!("{}", arg.identifier.0);
+    let arg_index = arg_index as i32;
+
+    let load_arg = quote! {
+        args.get(#arg_index)
+    };
+
+    let default = arg.default.map(|default| match default.value {
+        DefaultValue::String(value) => syn::parse_str::<syn::Expr>(value.0).unwrap(),
+        _ => unimplemented!("non-string default values are not supported yet"),
+    });
+
+    let is_optional = arg.optional.is_some();
+    let parse_arg = match definitions.resolve_type(&arg.type_.type_) {
+        TypeKind::Interface {
+            rust_type,
+            optional,
+        } => {
+            let mut rust_type = quote! {
+                std::cell::Ref<#rust_type>
+            };
+
+            if is_optional || optional {
+                rust_type = quote! {
+                    Option<#rust_type>
+                };
+            }
+
+            quote! {
+                <#rust_type as FromV8>::from_v8(scope, #load_arg)
+                    .expect("could not load native object from JS value")
+            }
+        }
+
+        TypeKind::Value { rust_type } => {
+            let mut rust_type = quote! {
+                #rust_type
+            };
+
+            if is_optional {
+                rust_type = quote! {
+                    Option<#rust_type>
+                };
+            }
+
+            quote! {
+                <#rust_type as FromV8>::from_v8(scope, #load_arg)
+                    .expect("failed to deserialize argument from V8 value")
+            }
+        }
+    };
+
+    let parse_arg = if is_cloned {
+        quote! {
+            #parse_arg.clone()
+        }
+    } else {
+        parse_arg
+    };
+
+    let arg_binding = if let Some(default) = default {
+        quote! {
+            let #arg_ident = if let Some(#arg_ident) = #parse_arg { #arg_ident } else { #default };
+        }
+    } else {
+        quote! {
+            let #arg_ident = #parse_arg;
+        }
+    };
+
+    arg_bindings.push(arg_binding);
+
+    arg_idents.push(if is_by_ref {
+        quote! { &#arg_ident }
+    } else {
+        quote! { #arg_ident }
+    });
+}
+
+enum TypeKind {
+    Interface {
+        rust_type: syn::Type,
+        optional: bool,
+    },
+    Value {
+        rust_type: syn::Type,
+    },
+}
+
+impl TypeKind {
+    fn with_optional(self, with_optional: bool) -> Self {
+        match self {
+            TypeKind::Interface {
+                rust_type,
+                optional,
+            } => TypeKind::Interface {
+                rust_type,
+                optional: optional || with_optional,
+            },
+            other => other,
+        }
+    }
+}
+
+struct DefinitionsMap<'a> {
+    inner: BTreeMap<String, Definition<'a>>,
+}
+
+impl<'a> DefinitionsMap<'a> {
+    fn new(definitions: Vec<Definition<'a>>) -> Self {
+        let mut inner = BTreeMap::default();
+
+        for definition in definitions {
+            let key = match &definition {
+                Definition::Interface(interface) => interface.identifier.0,
+                Definition::Namespace(namespace) => namespace.identifier.0,
+                Definition::Typedef(typedef) => typedef.identifier.0,
+                Definition::Enum(enum_) => enum_.identifier.0,
+                _ => unimplemented!(
+                    "this type of definitions is not implemented yet: {definition:?}"
+                ),
+            };
+
+            inner.insert(key.into(), definition);
+        }
+
+        Self { inner }
+    }
+
+    fn resolve_type(&self, ty: &Type) -> TypeKind {
+        match ty {
+            Type::Single(SingleType::NonAny(NonAnyType::Identifier(id))) => self
+                .resolve_name(&id.type_)
+                .with_optional(id.q_mark.is_some()),
+
+            Type::Single(SingleType::NonAny(NonAnyType::Integer(ty))) => TypeKind::Value {
+                rust_type: with_optional(
+                    ty,
+                    match &ty.type_ {
+                        IntegerType::Short(ty) => {
+                            if ty.unsigned.is_some() {
+                                parse_quote! { u16 }
+                            } else {
+                                parse_quote! { i16 }
+                            }
+                        }
+                        IntegerType::Long(ty) => {
+                            if ty.unsigned.is_some() {
+                                parse_quote! { u32 }
+                            } else {
+                                parse_quote! { i32 }
+                            }
+                        }
+                        IntegerType::LongLong(ty) => {
+                            if ty.unsigned.is_some() {
+                                parse_quote! { u64 }
+                            } else {
+                                parse_quote! { i64 }
+                            }
+                        }
+                    },
+                ),
+            },
+
+            Type::Single(SingleType::NonAny(NonAnyType::FloatingPoint(ty))) => TypeKind::Value {
+                rust_type: with_optional(
+                    ty,
+                    match &ty.type_ {
+                        FloatingPointType::Float(_) => parse_quote! { f32 },
+                        FloatingPointType::Double(_) => parse_quote! { f64 },
+                    },
+                ),
+            },
+
+            Type::Single(SingleType::NonAny(NonAnyType::Boolean(ty))) => TypeKind::Value {
+                rust_type: with_optional(ty, parse_quote! { bool }),
+            },
+
+            Type::Single(SingleType::NonAny(NonAnyType::DOMString(ty))) => TypeKind::Value {
+                rust_type: with_optional(ty, parse_quote! { String }),
+            },
+
+            Type::Single(SingleType::NonAny(NonAnyType::Sequence(ty))) => {
+                match self.resolve_type(&ty.type_.generics.body) {
+                    TypeKind::Value { rust_type } => TypeKind::Value {
+                        rust_type: with_optional(ty, parse_quote! { Vec<#rust_type> }),
+                    },
+                    TypeKind::Interface { .. } => {
+                        unimplemented!("sequences of interfaces are not supported, please manage the serialization manually using [CustomBinding]")
+                    }
+                }
+            }
+
+            Type::Single(SingleType::Any(_)) => TypeKind::Value {
+                rust_type: parse_quote! { serde_v8::Value },
+            },
+
+            Type::Union(_) => unimplemented!("union types are not supported"),
+            Type::Single(SingleType::NonAny(ty)) => {
+                unimplemented!("type {ty:?} is not implemented")
+            }
+        }
+    }
+
+    fn resolve_name(&self, name: &Identifier) -> TypeKind {
+        match self.inner.get(name.0) {
+            Some(Definition::Typedef(typedef)) => typedef
+                .attributes
+                .as_ref()
+                .and_then(|attrs| {
+                    Some(TypeKind::Value {
+                        rust_type: find_rust_type_attribute(attrs)?,
+                    })
+                })
+                .unwrap_or_else(|| self.resolve_type(&typedef.type_.type_)),
+            Some(Definition::Enum(enum_)) => enum_
+                .attributes
+                .as_ref()
+                .and_then(|attrs| {
+                    Some(TypeKind::Value {
+                        rust_type: find_rust_type_attribute(attrs)?,
+                    })
+                })
+                .unwrap_or_else(|| panic!("enum {} has no RustType attribute", enum_.identifier.0)),
+
+            Some(Definition::Interface(interface)) => TypeKind::Interface {
+                rust_type: find_rust_type(interface),
+                optional: false,
+            },
+
+            None => panic!("type not found: {:?}", name.0),
+            Some(def) => unimplemented!("unsupported definition {def:?}"),
+        }
+    }
+
+    fn iter<'b>(&'b self) -> btree_map::Iter<'b, String, Definition<'a>> {
+        self.inner.iter()
+    }
+}
+
+fn with_optional<T>(outer: &MayBeNull<T>, inner: syn::Type) -> syn::Type {
+    if outer.q_mark.is_some() {
+        parse_quote! { Option<#inner> }
+    } else {
+        inner
+    }
+}
+
+fn find_rust_type<'a, D: ClassDefinition<'a>>(interface: &D) -> syn::Type {
+    interface
+        .attributes()
+        .and_then(find_rust_type_attribute)
+        .unwrap_or_else(|| {
+            let id = format_ident!("{}", interface.identifier());
+            parse_quote! { #id }
+        })
+}
+
+fn find_rust_type_attribute(
+    attributes: &Bracketed<Punctuated<ExtendedAttribute, Comma>>,
+) -> Option<syn::Type> {
+    attributes.body.list.iter().find_map(|attr| match attr {
+        ExtendedAttribute::Ident(attr) if attr.lhs_identifier.0 == "RustType" => match attr.rhs {
+            IdentifierOrString::String(value) => Some(
+                parse_str::<syn::Type>(value.0)
+                    .expect("failed to parse value of RustType attribute"),
+            ),
+            IdentifierOrString::Identifier(_) => {
+                panic!("unexpected identifier value for attribute RustType, expected string")
+            }
+        },
+        _ => None,
+    })
+}
diff --git a/crates/rome_rowan/src/cursor.rs b/crates/rome_rowan/src/cursor.rs
index dbec7c07ccd..8d5873da503 100644
--- a/crates/rome_rowan/src/cursor.rs
+++ b/crates/rome_rowan/src/cursor.rs
@@ -59,8 +59,8 @@ use crate::{
 };
 pub(crate) use element::SyntaxElement;
 pub(crate) use node::{
-    Preorder, PreorderWithTokens, SyntaxElementChildren, SyntaxNode, SyntaxNodeChildren,
-    SyntaxSlot, SyntaxSlots,
+    Descendants, DescendantsWithTokens, Preorder, PreorderWithTokens, SyntaxElementChildren,
+    SyntaxNode, SyntaxNodeChildren, SyntaxSlot, SyntaxSlots,
 };
 
 #[derive(Debug)]
diff --git a/crates/rome_rowan/src/cursor/node.rs b/crates/rome_rowan/src/cursor/node.rs
index 3846e2a0a26..f4fe0871459 100644
--- a/crates/rome_rowan/src/cursor/node.rs
+++ b/crates/rome_rowan/src/cursor/node.rs
@@ -15,7 +15,7 @@ use std::{fmt, iter};
 use super::{GreenElement, NodeKind, WeakGreenElement};
 
 #[derive(Clone)]
-pub(crate) struct SyntaxNode {
+pub struct SyntaxNode {
     pub(super) ptr: Rc<NodeData>,
 }
 
@@ -122,26 +122,26 @@ impl SyntaxNode {
         TextRange::new(start, end.max(start))
     }
 
-    pub fn first_leading_trivia(&self) -> Option<SyntaxTrivia> {
+    pub(crate) fn first_leading_trivia(&self) -> Option<SyntaxTrivia> {
         self.first_token().map(|x| x.leading_trivia())
     }
 
-    pub fn last_trailing_trivia(&self) -> Option<SyntaxTrivia> {
+    pub(crate) fn last_trailing_trivia(&self) -> Option<SyntaxTrivia> {
         self.last_token().map(|x| x.trailing_trivia())
     }
 
     #[inline]
-    pub fn index(&self) -> usize {
+    pub(crate) fn index(&self) -> usize {
         self.data().slot() as usize
     }
 
     #[inline]
-    pub fn text(&self) -> SyntaxNodeText {
+    pub(crate) fn text(&self) -> SyntaxNodeText {
         SyntaxNodeText::new(self.clone())
     }
 
     #[inline]
-    pub fn text_trimmed(&self) -> SyntaxNodeText {
+    pub(crate) fn text_trimmed(&self) -> SyntaxNodeText {
         SyntaxNodeText::with_range(self.clone(), self.text_trimmed_range())
     }
 
@@ -156,27 +156,27 @@ impl SyntaxNode {
     }
 
     #[inline]
-    pub fn parent(&self) -> Option<SyntaxNode> {
+    pub(crate) fn parent(&self) -> Option<SyntaxNode> {
         self.data().parent_node()
     }
 
     #[inline]
-    pub fn ancestors(&self) -> impl Iterator<Item = SyntaxNode> {
+    pub(crate) fn ancestors(&self) -> impl Iterator<Item = SyntaxNode> {
         iter::successors(Some(self.clone()), SyntaxNode::parent)
     }
 
     #[inline]
-    pub fn children(&self) -> SyntaxNodeChildren {
+    pub(crate) fn children(&self) -> SyntaxNodeChildren {
         SyntaxNodeChildren::new(self.clone())
     }
 
     #[inline]
-    pub fn children_with_tokens(&self) -> SyntaxElementChildren {
+    pub(crate) fn children_with_tokens(&self) -> SyntaxElementChildren {
         SyntaxElementChildren::new(self.clone())
     }
 
     #[inline]
-    pub fn tokens(&self) -> impl Iterator<Item = SyntaxToken> + DoubleEndedIterator + '_ {
+    pub(crate) fn tokens(&self) -> impl Iterator<Item = SyntaxToken> + DoubleEndedIterator + '_ {
         self.green().children().filter_map(|child| {
             child.element().into_token().map(|token| {
                 SyntaxToken::new(
@@ -189,7 +189,7 @@ impl SyntaxNode {
         })
     }
 
-    pub fn first_child(&self) -> Option<SyntaxNode> {
+    pub(crate) fn first_child(&self) -> Option<SyntaxNode> {
         self.green().children().find_map(|child| {
             child.element().into_node().map(|green| {
                 SyntaxNode::new_child(
@@ -202,7 +202,7 @@ impl SyntaxNode {
         })
     }
 
-    pub fn last_child(&self) -> Option<SyntaxNode> {
+    pub(crate) fn last_child(&self) -> Option<SyntaxNode> {
         self.green().children().rev().find_map(|child| {
             child.element().into_node().map(|green| {
                 SyntaxNode::new_child(
@@ -215,7 +215,7 @@ impl SyntaxNode {
         })
     }
 
-    pub fn first_child_or_token(&self) -> Option<SyntaxElement> {
+    pub(crate) fn first_child_or_token(&self) -> Option<SyntaxElement> {
         self.green().children().next().map(|child| {
             SyntaxElement::new(
                 child.element(),
@@ -225,7 +225,7 @@ impl SyntaxNode {
             )
         })
     }
-    pub fn last_child_or_token(&self) -> Option<SyntaxElement> {
+    pub(crate) fn last_child_or_token(&self) -> Option<SyntaxElement> {
         self.green().children().next_back().map(|child| {
             SyntaxElement::new(
                 child.element(),
@@ -236,26 +236,26 @@ impl SyntaxNode {
         })
     }
 
-    pub fn next_sibling(&self) -> Option<SyntaxNode> {
+    pub(crate) fn next_sibling(&self) -> Option<SyntaxNode> {
         self.data().next_sibling()
     }
-    pub fn prev_sibling(&self) -> Option<SyntaxNode> {
+    pub(crate) fn prev_sibling(&self) -> Option<SyntaxNode> {
         self.data().prev_sibling()
     }
 
-    pub fn next_sibling_or_token(&self) -> Option<SyntaxElement> {
+    pub(crate) fn next_sibling_or_token(&self) -> Option<SyntaxElement> {
         self.data().next_sibling_or_token()
     }
-    pub fn prev_sibling_or_token(&self) -> Option<SyntaxElement> {
+    pub(crate) fn prev_sibling_or_token(&self) -> Option<SyntaxElement> {
         self.data().prev_sibling_or_token()
     }
 
-    pub fn first_token(&self) -> Option<SyntaxToken> {
+    pub(crate) fn first_token(&self) -> Option<SyntaxToken> {
         self.descendants_with_tokens(Direction::Next)
             .find_map(|x| x.into_token())
     }
 
-    pub fn last_token(&self) -> Option<SyntaxToken> {
+    pub(crate) fn last_token(&self) -> Option<SyntaxToken> {
         PreorderWithTokens::new(self.clone(), Direction::Prev)
             .filter_map(|event| match event {
                 WalkEvent::Enter(it) => Some(it),
@@ -265,7 +265,7 @@ impl SyntaxNode {
     }
 
     #[inline]
-    pub fn siblings(&self, direction: Direction) -> impl Iterator<Item = SyntaxNode> {
+    pub(crate) fn siblings(&self, direction: Direction) -> impl Iterator<Item = SyntaxNode> {
         iter::successors(Some(self.clone()), move |node| match direction {
             Direction::Next => node.next_sibling(),
             Direction::Prev => node.prev_sibling(),
@@ -273,7 +273,7 @@ impl SyntaxNode {
     }
 
     #[inline]
-    pub fn siblings_with_tokens(
+    pub(crate) fn siblings_with_tokens(
         &self,
         direction: Direction,
     ) -> impl Iterator<Item = SyntaxElement> {
@@ -285,7 +285,7 @@ impl SyntaxNode {
     }
 
     #[inline]
-    pub fn descendants(&self) -> impl Iterator<Item = SyntaxNode> {
+    pub(crate) fn descendants(&self) -> Descendants {
         self.preorder().filter_map(|event| match event {
             WalkEvent::Enter(node) => Some(node),
             WalkEvent::Leave(_) => None,
@@ -293,10 +293,7 @@ impl SyntaxNode {
     }
 
     #[inline]
-    pub fn descendants_with_tokens(
-        &self,
-        direction: Direction,
-    ) -> impl Iterator<Item = SyntaxElement> {
+    pub(crate) fn descendants_with_tokens(&self, direction: Direction) -> DescendantsWithTokens {
         self.preorder_with_tokens(direction)
             .filter_map(|event| match event {
                 WalkEvent::Enter(it) => Some(it),
@@ -305,12 +302,12 @@ impl SyntaxNode {
     }
 
     #[inline]
-    pub fn preorder(&self) -> Preorder {
+    pub(crate) fn preorder(&self) -> Preorder {
         Preorder::new(self.clone())
     }
 
     #[inline]
-    pub fn preorder_with_tokens(&self, direction: Direction) -> PreorderWithTokens {
+    pub(crate) fn preorder_with_tokens(&self, direction: Direction) -> PreorderWithTokens {
         PreorderWithTokens::new(self.clone(), direction)
     }
 
@@ -318,7 +315,7 @@ impl SyntaxNode {
         SlotsPreorder::new(self.clone())
     }
 
-    pub fn token_at_offset(&self, offset: TextSize) -> TokenAtOffset<SyntaxToken> {
+    pub(crate) fn token_at_offset(&self, offset: TextSize) -> TokenAtOffset<SyntaxToken> {
         // TODO: this could be faster if we first drill-down to node, and only
         // then switch to token search. We should also replace explicit
         // recursion with a loop.
@@ -354,7 +351,7 @@ impl SyntaxNode {
         }
     }
 
-    pub fn covering_element(&self, range: TextRange) -> SyntaxElement {
+    pub(crate) fn covering_element(&self, range: TextRange) -> SyntaxElement {
         let mut res: SyntaxElement = self.clone().into();
         loop {
             assert!(
@@ -373,7 +370,7 @@ impl SyntaxNode {
         }
     }
 
-    pub fn child_or_token_at_range(&self, range: TextRange) -> Option<SyntaxElement> {
+    pub(crate) fn child_or_token_at_range(&self, range: TextRange) -> Option<SyntaxElement> {
         let rel_range = range - self.offset();
         self.green()
             .slot_at_range(rel_range)
@@ -390,14 +387,14 @@ impl SyntaxNode {
     }
 
     #[must_use = "syntax elements are immutable, the result of update methods must be propagated to have any effect"]
-    pub fn detach(self) -> Self {
+    pub(crate) fn detach(self) -> Self {
         Self {
             ptr: self.ptr.detach(),
         }
     }
 
     #[must_use = "syntax elements are immutable, the result of update methods must be propagated to have any effect"]
-    pub fn splice_slots<R, I>(self, range: R, replace_with: I) -> Self
+    pub(crate) fn splice_slots<R, I>(self, range: R, replace_with: I) -> Self
     where
         R: ops::RangeBounds<usize>,
         I: Iterator<Item = Option<SyntaxElement>>,
@@ -416,7 +413,11 @@ impl SyntaxNode {
     }
 
     #[must_use = "syntax elements are immutable, the result of update methods must be propagated to have any effect"]
-    pub fn replace_child(self, prev_elem: SyntaxElement, next_elem: SyntaxElement) -> Option<Self> {
+    pub(crate) fn replace_child(
+        self,
+        prev_elem: SyntaxElement,
+        next_elem: SyntaxElement,
+    ) -> Option<Self> {
         Some(Self {
             ptr: self.ptr.replace_child(prev_elem, next_elem)?,
         })
@@ -512,7 +513,12 @@ impl Iterator for SyntaxElementChildren {
 
 impl FusedIterator for SyntaxElementChildren {}
 
-pub(crate) struct Preorder {
+pub type Descendants =
+    std::iter::FilterMap<Preorder, fn(WalkEvent<SyntaxNode>) -> Option<SyntaxNode>>;
+pub type DescendantsWithTokens =
+    std::iter::FilterMap<PreorderWithTokens, fn(WalkEvent<SyntaxElement>) -> Option<SyntaxElement>>;
+
+pub struct Preorder {
     start: SyntaxNode,
     next: Option<WalkEvent<SyntaxNode>>,
     skip_subtree: bool,
@@ -573,7 +579,7 @@ impl Iterator for Preorder {
 
 impl FusedIterator for Preorder {}
 
-pub(crate) struct PreorderWithTokens {
+pub struct PreorderWithTokens {
     start: SyntaxElement,
     next: Option<WalkEvent<SyntaxElement>>,
     skip_subtree: bool,
diff --git a/crates/rome_rowan/src/cursor/token.rs b/crates/rome_rowan/src/cursor/token.rs
index a9a0e53ab7a..b9121158c41 100644
--- a/crates/rome_rowan/src/cursor/token.rs
+++ b/crates/rome_rowan/src/cursor/token.rs
@@ -10,7 +10,7 @@ use std::{fmt, iter};
 use super::{GreenElement, NodeKind, WeakGreenElement};
 
 #[derive(Clone, Debug)]
-pub(crate) struct SyntaxToken {
+pub struct SyntaxToken {
     ptr: Rc<NodeData>,
 }
 
@@ -222,12 +222,12 @@ impl SyntaxToken {
     }
 
     #[inline]
-    pub fn leading_trivia(&self) -> SyntaxTrivia {
+    pub(crate) fn leading_trivia(&self) -> SyntaxTrivia {
         SyntaxTrivia::leading(self.clone())
     }
 
     #[inline]
-    pub fn trailing_trivia(&self) -> SyntaxTrivia {
+    pub(crate) fn trailing_trivia(&self) -> SyntaxTrivia {
         SyntaxTrivia::trailing(self.clone())
     }
 }
diff --git a/crates/rome_rowan/src/serde_impls.rs b/crates/rome_rowan/src/serde_impls.rs
index 3849416bf63..df0d3d01503 100644
--- a/crates/rome_rowan/src/serde_impls.rs
+++ b/crates/rome_rowan/src/serde_impls.rs
@@ -1,9 +1,12 @@
-use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
+use serde::{
+    ser::{Serialize, SerializeMap, SerializeSeq, Serializer},
+    Deserialize, Deserializer,
+};
 use std::fmt;
 
 use crate::{
     syntax::{Language, SyntaxNode, SyntaxToken},
-    NodeOrToken,
+    NodeOrToken, RawSyntaxKind,
 };
 
 struct SerDisplay<T>(T);
@@ -71,6 +74,24 @@ impl<L: Language> Serialize for Children<&'_ SyntaxNode<L>> {
     }
 }
 
+impl Serialize for RawSyntaxKind {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_u16(self.0)
+    }
+}
+
+impl<'de> Deserialize<'de> for RawSyntaxKind {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        u16::deserialize(deserializer).map(Self)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use crate::raw_language::{RawLanguage, RawLanguageKind, RawLanguageSyntaxFactory};
diff --git a/crates/rome_rowan/src/syntax.rs b/crates/rome_rowan/src/syntax.rs
index 3af0327e7c6..d2234cbac22 100644
--- a/crates/rome_rowan/src/syntax.rs
+++ b/crates/rome_rowan/src/syntax.rs
@@ -8,8 +8,8 @@ use crate::{AstNode, RawSyntaxKind};
 pub use element::{SyntaxElement, SyntaxElementKey};
 pub(crate) use node::SyntaxSlots;
 pub use node::{
-    Preorder, PreorderWithTokens, SendNode, SyntaxElementChildren, SyntaxNode, SyntaxNodeChildren,
-    SyntaxNodeOptionExt, SyntaxSlot,
+    Descendants, DescendantsTokens, DescendantsWithTokens, Preorder, PreorderWithTokens, SendNode,
+    SyntaxElementChildren, SyntaxNode, SyntaxNodeChildren, SyntaxNodeOptionExt, SyntaxSlot,
 };
 pub use rewriter::{SyntaxRewriter, VisitNodeSignal};
 use std::fmt;
diff --git a/crates/rome_rowan/src/syntax/node.rs b/crates/rome_rowan/src/syntax/node.rs
index a25f4094966..e67ab030a7f 100644
--- a/crates/rome_rowan/src/syntax/node.rs
+++ b/crates/rome_rowan/src/syntax/node.rs
@@ -341,19 +341,16 @@ impl<L: Language> SyntaxNode<L> {
             .map(SyntaxElement::from)
     }
 
-    pub fn descendants(&self) -> impl Iterator<Item = SyntaxNode<L>> {
+    pub fn descendants(&self) -> Descendants<L> {
         self.raw.descendants().map(SyntaxNode::from)
     }
 
-    pub fn descendants_tokens(&self, direction: Direction) -> impl Iterator<Item = SyntaxToken<L>> {
+    pub fn descendants_tokens(&self, direction: Direction) -> DescendantsTokens<L> {
         self.descendants_with_tokens(direction)
             .filter_map(|x| x.as_token().cloned())
     }
 
-    pub fn descendants_with_tokens(
-        &self,
-        direction: Direction,
-    ) -> impl Iterator<Item = SyntaxElement<L>> {
+    pub fn descendants_with_tokens(&self, direction: Direction) -> DescendantsWithTokens<L> {
         self.raw
             .descendants_with_tokens(direction)
             .map(NodeOrToken::from)
@@ -873,6 +870,13 @@ impl<L: Language> Iterator for SyntaxElementChildren<L> {
     }
 }
 
+pub type Descendants<L> =
+    std::iter::Map<cursor::Descendants, fn(cursor::SyntaxNode) -> SyntaxNode<L>>;
+pub type DescendantsTokens<L> =
+    std::iter::FilterMap<DescendantsWithTokens<L>, fn(SyntaxElement<L>) -> Option<SyntaxToken<L>>>;
+pub type DescendantsWithTokens<L> =
+    std::iter::Map<cursor::DescendantsWithTokens, fn(cursor::SyntaxElement) -> SyntaxElement<L>>;
+
 pub struct Preorder<L: Language> {
     raw: cursor::Preorder,
     _p: PhantomData<L>,
diff --git a/crates/rome_rowan/src/utility_types.rs b/crates/rome_rowan/src/utility_types.rs
index f710606477c..bac8b6dc1bc 100644
--- a/crates/rome_rowan/src/utility_types.rs
+++ b/crates/rome_rowan/src/utility_types.rs
@@ -55,6 +55,7 @@ impl<N: fmt::Display, T: fmt::Display> fmt::Display for NodeOrToken<N, T> {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Direction {
     Next,
     Prev,
diff --git a/crates/rome_v8/Cargo.toml b/crates/rome_v8/Cargo.toml
new file mode 100644
index 00000000000..2629ccfa14d
--- /dev/null
+++ b/crates/rome_v8/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+edition = "2021"
+name    = "rome_v8"
+version = "0.1.0"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow   = "1.0.57"
+serde    = { workspace = true }
+serde_v8 = { version = "0.108.0" }
+v8       = { version = "0.74.3", default-features = false }
+
+rome_js_factory = { workspace = true }
+rome_js_syntax  = { workspace = true }
+rome_rowan      = { workspace = true, features = ["serde"] }
+
+[dev-dependencies]
+bpaf             = { workspace = true }
+crossbeam        = { workspace = true }
+rome_console     = { workspace = true }
+rome_diagnostics = { workspace = true }
+rome_fs          = { workspace = true }
+rome_js_parser   = { workspace = true }
+rome_service     = { workspace = true }
+
+[build-dependencies]
+rome_idl = { path = "../rome_idl" }
diff --git a/crates/rome_v8/build.rs b/crates/rome_v8/build.rs
new file mode 100644
index 00000000000..ce202e570d8
--- /dev/null
+++ b/crates/rome_v8/build.rs
@@ -0,0 +1,12 @@
+use std::fs;
+
+fn main() {
+    const IDL_FILE: &str = "src/bindings/rowan.idl";
+
+    println!("cargo:rerun-if-changed={IDL_FILE}");
+
+    let source = fs::read_to_string(IDL_FILE).expect("failed to read IDL file");
+    let content = rome_idl::generate(&source);
+
+    fs::write("src/bindings/rowan.idl.rs", content).expect("failed to write generated code");
+}
diff --git a/crates/rome_v8/examples/codemod.rs b/crates/rome_v8/examples/codemod.rs
new file mode 100644
index 00000000000..41ca5ac3d00
--- /dev/null
+++ b/crates/rome_v8/examples/codemod.rs
@@ -0,0 +1,165 @@
+use bpaf::{construct, long, positional, OptionParser, Parser};
+use std::{
+    cell::RefCell,
+    collections::HashMap,
+    ffi::OsStr,
+    path::{Path, PathBuf},
+    thread,
+};
+
+use crossbeam::channel::{unbounded, Receiver, Sender};
+
+use rome_console::{markup, ColorMode, Console, ConsoleExt, EnvConsole};
+use rome_diagnostics::{Error, PrintDiagnostic};
+use rome_fs::{
+    self, FileSystem, FileSystemExt, OsFileSystem, PathInterner, RomePath, TraversalContext,
+};
+use rome_js_parser::{parse, JsParserOptions};
+use rome_js_syntax::JsFileSource;
+use rome_service::{workspace, App, DynRef, WorkspaceRef};
+use rome_v8::{Instance, Script};
+
+pub fn main() {
+    let mut console = EnvConsole::default();
+    console.set_color(ColorMode::Auto);
+    let app = App::new(
+        DynRef::Owned(Box::new(OsFileSystem)),
+        &mut console,
+        WorkspaceRef::Owned(workspace::server()),
+    );
+    let options = options().run();
+    let (script_name, script) = load_script(&*app.fs, &options);
+
+    let (send_diagnostics, recv_diagnostics) = unbounded();
+    let (interner, recv_files) = PathInterner::new();
+
+    let console = &mut *app.console;
+    let fs = &*app.fs;
+
+    let ctx = CodemodContext {
+        fs,
+        interner,
+        diagnostics: send_diagnostics,
+        script_name,
+        script,
+    };
+
+    thread::scope(move |scope| {
+        scope.spawn(move || {
+            console_thread(console, recv_diagnostics, recv_files);
+        });
+
+        let ctx = &ctx;
+        fs.traversal(Box::new(move |scope| {
+            for input in options.paths {
+                scope.spawn(ctx, input);
+            }
+        }));
+    });
+}
+
+struct CliOptions {
+    script_path: PathBuf,
+    paths: Vec<PathBuf>,
+}
+
+fn options() -> OptionParser<CliOptions> {
+    let script_path = long("script")
+        .help("Script to load at runtime")
+        .argument::<PathBuf>("PATH");
+    let paths = positional::<PathBuf>("PATH").many();
+
+    construct!(CliOptions { script_path, paths }).to_options()
+}
+
+fn load_script(fs: &dyn FileSystem, options: &CliOptions) -> (String, String) {
+    let mut script = fs.read(&options.script_path).unwrap_or_else(|err| {
+        panic!(
+            "could not open file {}: {err}",
+            options.script_path.display()
+        )
+    });
+
+    let mut buffer = String::new();
+    script.read_to_string(&mut buffer).unwrap();
+
+    (options.script_path.display().to_string(), buffer)
+}
+
+fn console_thread(
+    console: &mut dyn Console,
+    recv_diagnostics: Receiver<Error>,
+    _recv_files: Receiver<PathBuf>,
+) {
+    while let Ok(error) = recv_diagnostics.recv() {
+        console.error(markup! {
+            {PrintDiagnostic::simple(&error)}
+        });
+    }
+}
+
+struct CodemodContext<'app> {
+    fs: &'app dyn FileSystem,
+    interner: PathInterner,
+    diagnostics: Sender<Error>,
+    script_name: String,
+    script: String,
+}
+
+impl TraversalContext for CodemodContext<'_> {
+    fn interner(&self) -> &PathInterner {
+        &self.interner
+    }
+
+    fn push_diagnostic(&self, error: Error) {
+        self.diagnostics.send(error).ok();
+    }
+
+    fn can_handle(&self, path: &RomePath) -> bool {
+        let ext = match path.extension().and_then(OsStr::to_str) {
+            Some(ext) => ext,
+            None => return false,
+        };
+
+        matches!(
+            ext.to_lowercase().as_str(),
+            "js" | "mjs" | "cjs" | "jsx" | "ts" | "mts" | "cts" | "tsx"
+        )
+    }
+
+    fn handle_file(&self, path: &Path) {
+        let mut file = self
+            .fs
+            .open(path)
+            .unwrap_or_else(|err| panic!("could not open file {}: {err}", path.display()));
+
+        let mut buffer = String::new();
+        file.read_to_string(&mut buffer).unwrap();
+
+        let source_type = JsFileSource::try_from(path).unwrap();
+        let parse = parse(&buffer, source_type, JsParserOptions::default());
+        let root = parse.tree();
+
+        thread_local! {
+            static INSTANCE: RefCell<Instance> = RefCell::new(Instance::new().expect("failed to create V8 instance"));
+            static SCRIPT_CACHE: RefCell<HashMap<String, Script>> = RefCell::new(HashMap::new());
+        }
+
+        let result = INSTANCE.with(|instance| {
+            let mut instance = instance.borrow_mut();
+
+            SCRIPT_CACHE.with(|script_cache| {
+                let mut script_cache = script_cache.borrow_mut();
+
+                let script = script_cache
+                    .entry(self.script_name.clone())
+                    .or_insert_with(|| instance.load(&self.script_name, &self.script).unwrap());
+
+                instance.run(script, root).unwrap()
+            })
+        });
+
+        let output = result.to_string();
+        file.set_content(output.as_bytes()).unwrap();
+    }
+}
diff --git a/crates/rome_v8/examples/script.js b/crates/rome_v8/examples/script.js
new file mode 100644
index 00000000000..4f6d4d28023
--- /dev/null
+++ b/crates/rome_v8/examples/script.js
@@ -0,0 +1,13 @@
+export default function (root) {
+	const mutation = new JsBatchMutation(root);
+
+	for (const old_token of root.descendants_tokens()) {
+		if (old_token.kind() === JsSyntaxKind.IDENT) {
+			const new_text = old_token.text_trimmed().toUpperCase();
+			const new_token = make.ident(new_text);
+			mutation.replace_element(old_token, new_token);
+		}
+	}
+
+	return mutation;
+}
diff --git a/crates/rome_v8/examples/src/test.js b/crates/rome_v8/examples/src/test.js
new file mode 100644
index 00000000000..2ea721b3510
--- /dev/null
+++ b/crates/rome_v8/examples/src/test.js
@@ -0,0 +1 @@
+function test() {}
diff --git a/crates/rome_v8/examples/src/test.ts b/crates/rome_v8/examples/src/test.ts
new file mode 100644
index 00000000000..2ea721b3510
--- /dev/null
+++ b/crates/rome_v8/examples/src/test.ts
@@ -0,0 +1 @@
+function test() {}
diff --git a/crates/rome_v8/src/bindings.rs b/crates/rome_v8/src/bindings.rs
new file mode 100644
index 00000000000..2cc20052ef0
--- /dev/null
+++ b/crates/rome_v8/src/bindings.rs
@@ -0,0 +1,26 @@
+use std::rc::Rc;
+
+use anyhow::Result;
+
+use crate::registry::TemplateRegistry;
+
+mod js;
+mod rowan_idl;
+// mod css;
+// mod json;
+
+pub(crate) fn setup_context<'scope>(
+    scope: &mut v8::HandleScope<'scope, ()>,
+) -> Result<v8::Local<'scope, v8::ObjectTemplate>> {
+    let global = v8::ObjectTemplate::new(scope);
+    let mut registry = TemplateRegistry::default();
+
+    rowan_idl::register_interfaces(scope, global, &mut registry);
+    js::register_interfaces(scope, global, &mut registry);
+    // css::register_interfaces(scope, global, &mut registry);
+    // json::register_interfaces(scope, global, &mut registry);
+
+    scope.set_slot(Rc::new(registry));
+
+    Ok(global)
+}
diff --git a/crates/rome_v8/src/bindings/css.rs b/crates/rome_v8/src/bindings/css.rs
new file mode 100644
index 00000000000..545ec7dab7d
--- /dev/null
+++ b/crates/rome_v8/src/bindings/css.rs
@@ -0,0 +1,4791 @@
+//! Generated file, do not edit by hand, see `xtask/codegen`
+
+use super::TemplateRegistry;
+use crate::convert::{FromV8, ToV8};
+use rome_rowan::{AstNode as _, AstNodeList as _, AstSeparatedList as _};
+pub(super) fn register_interfaces(
+    scope: &mut v8::HandleScope<'_, ()>,
+    global: v8::Local<'_, v8::ObjectTemplate>,
+    registry: &mut TemplateRegistry,
+) {
+    registry
+        .build_enum::<rome_css_syntax::CssSyntaxKind>(scope, global, "CssSyntaxKind")
+        .variant("EOF", rome_css_syntax::CssSyntaxKind::EOF)
+        .variant("SEMICOLON", rome_css_syntax::CssSyntaxKind::SEMICOLON)
+        .variant("COMMA", rome_css_syntax::CssSyntaxKind::COMMA)
+        .variant("L_PAREN", rome_css_syntax::CssSyntaxKind::L_PAREN)
+        .variant("R_PAREN", rome_css_syntax::CssSyntaxKind::R_PAREN)
+        .variant("L_CURLY", rome_css_syntax::CssSyntaxKind::L_CURLY)
+        .variant("R_CURLY", rome_css_syntax::CssSyntaxKind::R_CURLY)
+        .variant("L_BRACK", rome_css_syntax::CssSyntaxKind::L_BRACK)
+        .variant("R_BRACK", rome_css_syntax::CssSyntaxKind::R_BRACK)
+        .variant("L_ANGLE", rome_css_syntax::CssSyntaxKind::L_ANGLE)
+        .variant("R_ANGLE", rome_css_syntax::CssSyntaxKind::R_ANGLE)
+        .variant("TILDE", rome_css_syntax::CssSyntaxKind::TILDE)
+        .variant("HASH", rome_css_syntax::CssSyntaxKind::HASH)
+        .variant("AMP", rome_css_syntax::CssSyntaxKind::AMP)
+        .variant("PIPE", rome_css_syntax::CssSyntaxKind::PIPE)
+        .variant("PLUS", rome_css_syntax::CssSyntaxKind::PLUS)
+        .variant("STAR", rome_css_syntax::CssSyntaxKind::STAR)
+        .variant("SLASH", rome_css_syntax::CssSyntaxKind::SLASH)
+        .variant("CARET", rome_css_syntax::CssSyntaxKind::CARET)
+        .variant("PERCENT", rome_css_syntax::CssSyntaxKind::PERCENT)
+        .variant("DOT", rome_css_syntax::CssSyntaxKind::DOT)
+        .variant("COLON", rome_css_syntax::CssSyntaxKind::COLON)
+        .variant("EQ", rome_css_syntax::CssSyntaxKind::EQ)
+        .variant("BANG", rome_css_syntax::CssSyntaxKind::BANG)
+        .variant("NEQ", rome_css_syntax::CssSyntaxKind::NEQ)
+        .variant("MINUS", rome_css_syntax::CssSyntaxKind::MINUS)
+        .variant("LTEQ", rome_css_syntax::CssSyntaxKind::LTEQ)
+        .variant("GTEQ", rome_css_syntax::CssSyntaxKind::GTEQ)
+        .variant("PLUSEQ", rome_css_syntax::CssSyntaxKind::PLUSEQ)
+        .variant("PIPEEQ", rome_css_syntax::CssSyntaxKind::PIPEEQ)
+        .variant("AMPEQ", rome_css_syntax::CssSyntaxKind::AMPEQ)
+        .variant("CARETEQ", rome_css_syntax::CssSyntaxKind::CARETEQ)
+        .variant("SLASHEQ", rome_css_syntax::CssSyntaxKind::SLASHEQ)
+        .variant("STAREQ", rome_css_syntax::CssSyntaxKind::STAREQ)
+        .variant("PERCENTEQ", rome_css_syntax::CssSyntaxKind::PERCENTEQ)
+        .variant("AT", rome_css_syntax::CssSyntaxKind::AT)
+        .variant("DOLLAR_EQ", rome_css_syntax::CssSyntaxKind::DOLLAR_EQ)
+        .variant("TILDE_EQ", rome_css_syntax::CssSyntaxKind::TILDE_EQ)
+        .variant("CDC", rome_css_syntax::CssSyntaxKind::CDC)
+        .variant("CDO", rome_css_syntax::CssSyntaxKind::CDO)
+        .variant("ALICEBLUE_KW", rome_css_syntax::CssSyntaxKind::ALICEBLUE_KW)
+        .variant(
+            "ANTIQUEWHITE_KW",
+            rome_css_syntax::CssSyntaxKind::ANTIQUEWHITE_KW,
+        )
+        .variant("AQUA_KW", rome_css_syntax::CssSyntaxKind::AQUA_KW)
+        .variant(
+            "AQUAMARINE_KW",
+            rome_css_syntax::CssSyntaxKind::AQUAMARINE_KW,
+        )
+        .variant("AZURE_KW", rome_css_syntax::CssSyntaxKind::AZURE_KW)
+        .variant("BEIGE_KW", rome_css_syntax::CssSyntaxKind::BEIGE_KW)
+        .variant("BISQUE_KW", rome_css_syntax::CssSyntaxKind::BISQUE_KW)
+        .variant("BLACK_KW", rome_css_syntax::CssSyntaxKind::BLACK_KW)
+        .variant(
+            "BLANCHEDALMOND_KW",
+            rome_css_syntax::CssSyntaxKind::BLANCHEDALMOND_KW,
+        )
+        .variant("BLUE_KW", rome_css_syntax::CssSyntaxKind::BLUE_KW)
+        .variant(
+            "BLUEVIOLET_KW",
+            rome_css_syntax::CssSyntaxKind::BLUEVIOLET_KW,
+        )
+        .variant("BROWN_KW", rome_css_syntax::CssSyntaxKind::BROWN_KW)
+        .variant("BURLYWOOD_KW", rome_css_syntax::CssSyntaxKind::BURLYWOOD_KW)
+        .variant("CADETBLUE_KW", rome_css_syntax::CssSyntaxKind::CADETBLUE_KW)
+        .variant(
+            "CHARTREUSE_KW",
+            rome_css_syntax::CssSyntaxKind::CHARTREUSE_KW,
+        )
+        .variant("CHOCOLATE_KW", rome_css_syntax::CssSyntaxKind::CHOCOLATE_KW)
+        .variant("CORAL_KW", rome_css_syntax::CssSyntaxKind::CORAL_KW)
+        .variant(
+            "CORNFLOWERBLUE_KW",
+            rome_css_syntax::CssSyntaxKind::CORNFLOWERBLUE_KW,
+        )
+        .variant("CORNSILK_KW", rome_css_syntax::CssSyntaxKind::CORNSILK_KW)
+        .variant("CRIMSON_KW", rome_css_syntax::CssSyntaxKind::CRIMSON_KW)
+        .variant("CYAN_KW", rome_css_syntax::CssSyntaxKind::CYAN_KW)
+        .variant("DARKBLUE_KW", rome_css_syntax::CssSyntaxKind::DARKBLUE_KW)
+        .variant("DARKCYAN_KW", rome_css_syntax::CssSyntaxKind::DARKCYAN_KW)
+        .variant(
+            "DARKGOLDENROD_KW",
+            rome_css_syntax::CssSyntaxKind::DARKGOLDENROD_KW,
+        )
+        .variant("DARKGRAY_KW", rome_css_syntax::CssSyntaxKind::DARKGRAY_KW)
+        .variant("DARKGREEN_KW", rome_css_syntax::CssSyntaxKind::DARKGREEN_KW)
+        .variant("DARKKHAKI_KW", rome_css_syntax::CssSyntaxKind::DARKKHAKI_KW)
+        .variant(
+            "DARKMAGENTA_KW",
+            rome_css_syntax::CssSyntaxKind::DARKMAGENTA_KW,
+        )
+        .variant(
+            "DARKOLIVEGREEN_KW",
+            rome_css_syntax::CssSyntaxKind::DARKOLIVEGREEN_KW,
+        )
+        .variant(
+            "DARKORANGE_KW",
+            rome_css_syntax::CssSyntaxKind::DARKORANGE_KW,
+        )
+        .variant(
+            "DARKORCHID_KW",
+            rome_css_syntax::CssSyntaxKind::DARKORCHID_KW,
+        )
+        .variant("DARKRED_KW", rome_css_syntax::CssSyntaxKind::DARKRED_KW)
+        .variant(
+            "DARKSALMON_KW",
+            rome_css_syntax::CssSyntaxKind::DARKSALMON_KW,
+        )
+        .variant(
+            "DARKSEAGREEN_KW",
+            rome_css_syntax::CssSyntaxKind::DARKSEAGREEN_KW,
+        )
+        .variant(
+            "DARKSLATEBLUE_KW",
+            rome_css_syntax::CssSyntaxKind::DARKSLATEBLUE_KW,
+        )
+        .variant(
+            "DARKSLATEGRAY_KW",
+            rome_css_syntax::CssSyntaxKind::DARKSLATEGRAY_KW,
+        )
+        .variant(
+            "DARKTURQUOISE_KW",
+            rome_css_syntax::CssSyntaxKind::DARKTURQUOISE_KW,
+        )
+        .variant(
+            "DARKVIOLET_KW",
+            rome_css_syntax::CssSyntaxKind::DARKVIOLET_KW,
+        )
+        .variant("DEEPPINK_KW", rome_css_syntax::CssSyntaxKind::DEEPPINK_KW)
+        .variant(
+            "DEEPSKYBLUE_KW",
+            rome_css_syntax::CssSyntaxKind::DEEPSKYBLUE_KW,
+        )
+        .variant("DIMGRAY_KW", rome_css_syntax::CssSyntaxKind::DIMGRAY_KW)
+        .variant(
+            "DODGERBLUE_KW",
+            rome_css_syntax::CssSyntaxKind::DODGERBLUE_KW,
+        )
+        .variant("FIREBRICK_KW", rome_css_syntax::CssSyntaxKind::FIREBRICK_KW)
+        .variant(
+            "FLORALWHITE_KW",
+            rome_css_syntax::CssSyntaxKind::FLORALWHITE_KW,
+        )
+        .variant(
+            "FORESTGREEN_KW",
+            rome_css_syntax::CssSyntaxKind::FORESTGREEN_KW,
+        )
+        .variant("FUCHSIA_KW", rome_css_syntax::CssSyntaxKind::FUCHSIA_KW)
+        .variant("GAINSBORO_KW", rome_css_syntax::CssSyntaxKind::GAINSBORO_KW)
+        .variant(
+            "GHOSTWHITE_KW",
+            rome_css_syntax::CssSyntaxKind::GHOSTWHITE_KW,
+        )
+        .variant("GOLD_KW", rome_css_syntax::CssSyntaxKind::GOLD_KW)
+        .variant("GOLDENROD_KW", rome_css_syntax::CssSyntaxKind::GOLDENROD_KW)
+        .variant("GRAY_KW", rome_css_syntax::CssSyntaxKind::GRAY_KW)
+        .variant("GREEN_KW", rome_css_syntax::CssSyntaxKind::GREEN_KW)
+        .variant(
+            "GREENYELLOW_KW",
+            rome_css_syntax::CssSyntaxKind::GREENYELLOW_KW,
+        )
+        .variant("HONEYDEW_KW", rome_css_syntax::CssSyntaxKind::HONEYDEW_KW)
+        .variant("HOTPINK_KW", rome_css_syntax::CssSyntaxKind::HOTPINK_KW)
+        .variant("INDIANRED_KW", rome_css_syntax::CssSyntaxKind::INDIANRED_KW)
+        .variant("INDIGO_KW", rome_css_syntax::CssSyntaxKind::INDIGO_KW)
+        .variant("IVORY_KW", rome_css_syntax::CssSyntaxKind::IVORY_KW)
+        .variant("KHAKI_KW", rome_css_syntax::CssSyntaxKind::KHAKI_KW)
+        .variant("LAVENDER_KW", rome_css_syntax::CssSyntaxKind::LAVENDER_KW)
+        .variant(
+            "LAVENDERBLUSH_KW",
+            rome_css_syntax::CssSyntaxKind::LAVENDERBLUSH_KW,
+        )
+        .variant("LAWNGREEN_KW", rome_css_syntax::CssSyntaxKind::LAWNGREEN_KW)
+        .variant(
+            "LEMONCHIFFON_KW",
+            rome_css_syntax::CssSyntaxKind::LEMONCHIFFON_KW,
+        )
+        .variant("LIGHTBLUE_KW", rome_css_syntax::CssSyntaxKind::LIGHTBLUE_KW)
+        .variant(
+            "LIGHTCORAL_KW",
+            rome_css_syntax::CssSyntaxKind::LIGHTCORAL_KW,
+        )
+        .variant("LIGHTCYAN_KW", rome_css_syntax::CssSyntaxKind::LIGHTCYAN_KW)
+        .variant(
+            "LIGHTGOLDENRODYELLOW_KW",
+            rome_css_syntax::CssSyntaxKind::LIGHTGOLDENRODYELLOW_KW,
+        )
+        .variant(
+            "LIGHTGREEN_KW",
+            rome_css_syntax::CssSyntaxKind::LIGHTGREEN_KW,
+        )
+        .variant("LIGHTGREY_KW", rome_css_syntax::CssSyntaxKind::LIGHTGREY_KW)
+        .variant("LIGHTPINK_KW", rome_css_syntax::CssSyntaxKind::LIGHTPINK_KW)
+        .variant(
+            "LIGHTSALMON_KW",
+            rome_css_syntax::CssSyntaxKind::LIGHTSALMON_KW,
+        )
+        .variant(
+            "LIGHTSEAGREEN_KW",
+            rome_css_syntax::CssSyntaxKind::LIGHTSEAGREEN_KW,
+        )
+        .variant(
+            "LIGHTSKYBLUE_KW",
+            rome_css_syntax::CssSyntaxKind::LIGHTSKYBLUE_KW,
+        )
+        .variant(
+            "LIGHTSLATEGRAY_KW",
+            rome_css_syntax::CssSyntaxKind::LIGHTSLATEGRAY_KW,
+        )
+        .variant(
+            "LIGHTSTEELBLUE_KW",
+            rome_css_syntax::CssSyntaxKind::LIGHTSTEELBLUE_KW,
+        )
+        .variant(
+            "LIGHTYELLOW_KW",
+            rome_css_syntax::CssSyntaxKind::LIGHTYELLOW_KW,
+        )
+        .variant("LIME_KW", rome_css_syntax::CssSyntaxKind::LIME_KW)
+        .variant("LIMEGREEN_KW", rome_css_syntax::CssSyntaxKind::LIMEGREEN_KW)
+        .variant("LINEN_KW", rome_css_syntax::CssSyntaxKind::LINEN_KW)
+        .variant("MAGENTA_KW", rome_css_syntax::CssSyntaxKind::MAGENTA_KW)
+        .variant("MAROON_KW", rome_css_syntax::CssSyntaxKind::MAROON_KW)
+        .variant(
+            "MEDIUMAQUAMARINE_KW",
+            rome_css_syntax::CssSyntaxKind::MEDIUMAQUAMARINE_KW,
+        )
+        .variant(
+            "MEDIUMBLUE_KW",
+            rome_css_syntax::CssSyntaxKind::MEDIUMBLUE_KW,
+        )
+        .variant(
+            "MEDIUMORCHID_KW",
+            rome_css_syntax::CssSyntaxKind::MEDIUMORCHID_KW,
+        )
+        .variant(
+            "MEDIUMPURPLE_KW",
+            rome_css_syntax::CssSyntaxKind::MEDIUMPURPLE_KW,
+        )
+        .variant(
+            "MEDIUMSEAGREEN_KW",
+            rome_css_syntax::CssSyntaxKind::MEDIUMSEAGREEN_KW,
+        )
+        .variant(
+            "MEDIUMSLATEBLUE_KW",
+            rome_css_syntax::CssSyntaxKind::MEDIUMSLATEBLUE_KW,
+        )
+        .variant(
+            "MEDIUMSPRINGGREEN_KW",
+            rome_css_syntax::CssSyntaxKind::MEDIUMSPRINGGREEN_KW,
+        )
+        .variant(
+            "MEDIUMTURQUOISE_KW",
+            rome_css_syntax::CssSyntaxKind::MEDIUMTURQUOISE_KW,
+        )
+        .variant(
+            "MEDIUMVIOLETRED_KW",
+            rome_css_syntax::CssSyntaxKind::MEDIUMVIOLETRED_KW,
+        )
+        .variant(
+            "MIDNIGHTBLUE_KW",
+            rome_css_syntax::CssSyntaxKind::MIDNIGHTBLUE_KW,
+        )
+        .variant("MINTCREAM_KW", rome_css_syntax::CssSyntaxKind::MINTCREAM_KW)
+        .variant("MISTYROSE_KW", rome_css_syntax::CssSyntaxKind::MISTYROSE_KW)
+        .variant("MOCCASIN_KW", rome_css_syntax::CssSyntaxKind::MOCCASIN_KW)
+        .variant(
+            "NAVAJOWHITE_KW",
+            rome_css_syntax::CssSyntaxKind::NAVAJOWHITE_KW,
+        )
+        .variant("NAVY_KW", rome_css_syntax::CssSyntaxKind::NAVY_KW)
+        .variant("NAVYBLUE_KW", rome_css_syntax::CssSyntaxKind::NAVYBLUE_KW)
+        .variant("OLDLACE_KW", rome_css_syntax::CssSyntaxKind::OLDLACE_KW)
+        .variant("OLIVE_KW", rome_css_syntax::CssSyntaxKind::OLIVE_KW)
+        .variant("OLIVEDRAB_KW", rome_css_syntax::CssSyntaxKind::OLIVEDRAB_KW)
+        .variant("ORANGE_KW", rome_css_syntax::CssSyntaxKind::ORANGE_KW)
+        .variant("ORANGERED_KW", rome_css_syntax::CssSyntaxKind::ORANGERED_KW)
+        .variant("ORCHID_KW", rome_css_syntax::CssSyntaxKind::ORCHID_KW)
+        .variant(
+            "PALEGOLDENROD_KW",
+            rome_css_syntax::CssSyntaxKind::PALEGOLDENROD_KW,
+        )
+        .variant("PALEGREEN_KW", rome_css_syntax::CssSyntaxKind::PALEGREEN_KW)
+        .variant(
+            "PALETURQUOISE_KW",
+            rome_css_syntax::CssSyntaxKind::PALETURQUOISE_KW,
+        )
+        .variant(
+            "PALEVIOLETRED_KW",
+            rome_css_syntax::CssSyntaxKind::PALEVIOLETRED_KW,
+        )
+        .variant(
+            "PAPAYAWHIP_KW",
+            rome_css_syntax::CssSyntaxKind::PAPAYAWHIP_KW,
+        )
+        .variant("PEACHPUFF_KW", rome_css_syntax::CssSyntaxKind::PEACHPUFF_KW)
+        .variant("PERU_KW", rome_css_syntax::CssSyntaxKind::PERU_KW)
+        .variant("PINK_KW", rome_css_syntax::CssSyntaxKind::PINK_KW)
+        .variant("PLUM_KW", rome_css_syntax::CssSyntaxKind::PLUM_KW)
+        .variant(
+            "POWDERBLUE_KW",
+            rome_css_syntax::CssSyntaxKind::POWDERBLUE_KW,
+        )
+        .variant("PURPLE_KW", rome_css_syntax::CssSyntaxKind::PURPLE_KW)
+        .variant("RED_KW", rome_css_syntax::CssSyntaxKind::RED_KW)
+        .variant("ROSYBROWN_KW", rome_css_syntax::CssSyntaxKind::ROSYBROWN_KW)
+        .variant("ROYALBLUE_KW", rome_css_syntax::CssSyntaxKind::ROYALBLUE_KW)
+        .variant(
+            "SADDLEBROWN_KW",
+            rome_css_syntax::CssSyntaxKind::SADDLEBROWN_KW,
+        )
+        .variant("SALMON_KW", rome_css_syntax::CssSyntaxKind::SALMON_KW)
+        .variant(
+            "SANDYBROWN_KW",
+            rome_css_syntax::CssSyntaxKind::SANDYBROWN_KW,
+        )
+        .variant("SEAGREEN_KW", rome_css_syntax::CssSyntaxKind::SEAGREEN_KW)
+        .variant("SEASHELL_KW", rome_css_syntax::CssSyntaxKind::SEASHELL_KW)
+        .variant("SIENNA_KW", rome_css_syntax::CssSyntaxKind::SIENNA_KW)
+        .variant("SILVER_KW", rome_css_syntax::CssSyntaxKind::SILVER_KW)
+        .variant("SKYBLUE_KW", rome_css_syntax::CssSyntaxKind::SKYBLUE_KW)
+        .variant("SLATEBLUE_KW", rome_css_syntax::CssSyntaxKind::SLATEBLUE_KW)
+        .variant("SLATEGRAY_KW", rome_css_syntax::CssSyntaxKind::SLATEGRAY_KW)
+        .variant("SNOW_KW", rome_css_syntax::CssSyntaxKind::SNOW_KW)
+        .variant(
+            "SPRINGGREEN_KW",
+            rome_css_syntax::CssSyntaxKind::SPRINGGREEN_KW,
+        )
+        .variant("STEELBLUE_KW", rome_css_syntax::CssSyntaxKind::STEELBLUE_KW)
+        .variant("TAN_KW", rome_css_syntax::CssSyntaxKind::TAN_KW)
+        .variant("TEAL_KW", rome_css_syntax::CssSyntaxKind::TEAL_KW)
+        .variant("THISTLE_KW", rome_css_syntax::CssSyntaxKind::THISTLE_KW)
+        .variant("TOMATO_KW", rome_css_syntax::CssSyntaxKind::TOMATO_KW)
+        .variant("TURQUOISE_KW", rome_css_syntax::CssSyntaxKind::TURQUOISE_KW)
+        .variant("VIOLET_KW", rome_css_syntax::CssSyntaxKind::VIOLET_KW)
+        .variant("WHEAT_KW", rome_css_syntax::CssSyntaxKind::WHEAT_KW)
+        .variant("WHITE_KW", rome_css_syntax::CssSyntaxKind::WHITE_KW)
+        .variant(
+            "WHITESMOKE_KW",
+            rome_css_syntax::CssSyntaxKind::WHITESMOKE_KW,
+        )
+        .variant("YELLOW_KW", rome_css_syntax::CssSyntaxKind::YELLOW_KW)
+        .variant(
+            "YELLOWGREEN_KW",
+            rome_css_syntax::CssSyntaxKind::YELLOWGREEN_KW,
+        )
+        .variant("MEDIA_KW", rome_css_syntax::CssSyntaxKind::MEDIA_KW)
+        .variant("KEYFRAMES_KW", rome_css_syntax::CssSyntaxKind::KEYFRAMES_KW)
+        .variant("NOT_KW", rome_css_syntax::CssSyntaxKind::NOT_KW)
+        .variant("AND_KW", rome_css_syntax::CssSyntaxKind::AND_KW)
+        .variant("ONLY_KW", rome_css_syntax::CssSyntaxKind::ONLY_KW)
+        .variant("OR_KW", rome_css_syntax::CssSyntaxKind::OR_KW)
+        .variant("I_KW", rome_css_syntax::CssSyntaxKind::I_KW)
+        .variant("IMPORTANT_KW", rome_css_syntax::CssSyntaxKind::IMPORTANT_KW)
+        .variant("FROM_KW", rome_css_syntax::CssSyntaxKind::FROM_KW)
+        .variant("TO_KW", rome_css_syntax::CssSyntaxKind::TO_KW)
+        .variant("VAR_KW", rome_css_syntax::CssSyntaxKind::VAR_KW)
+        .variant(
+            "CSS_STRING_LITERAL",
+            rome_css_syntax::CssSyntaxKind::CSS_STRING_LITERAL,
+        )
+        .variant(
+            "CSS_NUMBER_LITERAL",
+            rome_css_syntax::CssSyntaxKind::CSS_NUMBER_LITERAL,
+        )
+        .variant(
+            "CSS_CUSTOM_PROPERTY",
+            rome_css_syntax::CssSyntaxKind::CSS_CUSTOM_PROPERTY,
+        )
+        .variant(
+            "CSS_SPACE_LITERAL",
+            rome_css_syntax::CssSyntaxKind::CSS_SPACE_LITERAL,
+        )
+        .variant("ERROR_TOKEN", rome_css_syntax::CssSyntaxKind::ERROR_TOKEN)
+        .variant("IDENT", rome_css_syntax::CssSyntaxKind::IDENT)
+        .variant("NEWLINE", rome_css_syntax::CssSyntaxKind::NEWLINE)
+        .variant("WHITESPACE", rome_css_syntax::CssSyntaxKind::WHITESPACE)
+        .variant("COMMENT", rome_css_syntax::CssSyntaxKind::COMMENT)
+        .variant(
+            "MULTILINE_COMMENT",
+            rome_css_syntax::CssSyntaxKind::MULTILINE_COMMENT,
+        )
+        .variant("CSS_ROOT", rome_css_syntax::CssSyntaxKind::CSS_ROOT)
+        .variant(
+            "CSS_RULE_LIST",
+            rome_css_syntax::CssSyntaxKind::CSS_RULE_LIST,
+        )
+        .variant(
+            "CSS_ID_SELECTOR_PATTERN",
+            rome_css_syntax::CssSyntaxKind::CSS_ID_SELECTOR_PATTERN,
+        )
+        .variant("CSS_RULE", rome_css_syntax::CssSyntaxKind::CSS_RULE)
+        .variant(
+            "CSS_SELECTOR_LIST",
+            rome_css_syntax::CssSyntaxKind::CSS_SELECTOR_LIST,
+        )
+        .variant("CSS_SELECTOR", rome_css_syntax::CssSyntaxKind::CSS_SELECTOR)
+        .variant(
+            "CSS_ANY_FUNCTION",
+            rome_css_syntax::CssSyntaxKind::CSS_ANY_FUNCTION,
+        )
+        .variant(
+            "CSS_AT_KEYFRAMES",
+            rome_css_syntax::CssSyntaxKind::CSS_AT_KEYFRAMES,
+        )
+        .variant(
+            "CSS_AT_KEYFRAMES_BODY",
+            rome_css_syntax::CssSyntaxKind::CSS_AT_KEYFRAMES_BODY,
+        )
+        .variant("CSS_AT_MEDIA", rome_css_syntax::CssSyntaxKind::CSS_AT_MEDIA)
+        .variant(
+            "CSS_AT_MEDIA_QUERY",
+            rome_css_syntax::CssSyntaxKind::CSS_AT_MEDIA_QUERY,
+        )
+        .variant(
+            "CSS_AT_MEDIA_QUERY_CONSEQUENT",
+            rome_css_syntax::CssSyntaxKind::CSS_AT_MEDIA_QUERY_CONSEQUENT,
+        )
+        .variant(
+            "CSS_AT_MEDIA_QUERY_FEATURE",
+            rome_css_syntax::CssSyntaxKind::CSS_AT_MEDIA_QUERY_FEATURE,
+        )
+        .variant(
+            "CSS_AT_MEDIA_QUERY_FEATURE_BOOLEAN",
+            rome_css_syntax::CssSyntaxKind::CSS_AT_MEDIA_QUERY_FEATURE_BOOLEAN,
+        )
+        .variant(
+            "CSS_AT_MEDIA_QUERY_FEATURE_COMPARE",
+            rome_css_syntax::CssSyntaxKind::CSS_AT_MEDIA_QUERY_FEATURE_COMPARE,
+        )
+        .variant(
+            "CSS_AT_MEDIA_QUERY_FEATURE_PLAIN",
+            rome_css_syntax::CssSyntaxKind::CSS_AT_MEDIA_QUERY_FEATURE_PLAIN,
+        )
+        .variant(
+            "CSS_AT_MEDIA_QUERY_FEATURE_RANGE",
+            rome_css_syntax::CssSyntaxKind::CSS_AT_MEDIA_QUERY_FEATURE_RANGE,
+        )
+        .variant(
+            "CSS_AT_MEDIA_QUERY_RANGE",
+            rome_css_syntax::CssSyntaxKind::CSS_AT_MEDIA_QUERY_RANGE,
+        )
+        .variant(
+            "CSS_ATTRIBUTE",
+            rome_css_syntax::CssSyntaxKind::CSS_ATTRIBUTE,
+        )
+        .variant(
+            "CSS_ATTRIBUTE_MATCHER",
+            rome_css_syntax::CssSyntaxKind::CSS_ATTRIBUTE_MATCHER,
+        )
+        .variant(
+            "CSS_ATTRIBUTE_META",
+            rome_css_syntax::CssSyntaxKind::CSS_ATTRIBUTE_META,
+        )
+        .variant(
+            "CSS_ATTRIBUTE_MODIFIER",
+            rome_css_syntax::CssSyntaxKind::CSS_ATTRIBUTE_MODIFIER,
+        )
+        .variant(
+            "CSS_ATTRIBUTE_NAME",
+            rome_css_syntax::CssSyntaxKind::CSS_ATTRIBUTE_NAME,
+        )
+        .variant(
+            "CSS_ATTRIBUTE_SELECTOR_PATTERN",
+            rome_css_syntax::CssSyntaxKind::CSS_ATTRIBUTE_SELECTOR_PATTERN,
+        )
+        .variant("CSS_BLOCK", rome_css_syntax::CssSyntaxKind::CSS_BLOCK)
+        .variant(
+            "CSS_CLASS_SELECTOR_PATTERN",
+            rome_css_syntax::CssSyntaxKind::CSS_CLASS_SELECTOR_PATTERN,
+        )
+        .variant(
+            "CSS_COMBINATOR_SELECTOR_PATTERN",
+            rome_css_syntax::CssSyntaxKind::CSS_COMBINATOR_SELECTOR_PATTERN,
+        )
+        .variant(
+            "CSS_DECLARATION",
+            rome_css_syntax::CssSyntaxKind::CSS_DECLARATION,
+        )
+        .variant(
+            "CSS_DIMENSION",
+            rome_css_syntax::CssSyntaxKind::CSS_DIMENSION,
+        )
+        .variant(
+            "CSS_IDENTIFIER",
+            rome_css_syntax::CssSyntaxKind::CSS_IDENTIFIER,
+        )
+        .variant(
+            "CSS_KEYFRAMES_BLOCK",
+            rome_css_syntax::CssSyntaxKind::CSS_KEYFRAMES_BLOCK,
+        )
+        .variant(
+            "CSS_KEYFRAMES_SELECTOR",
+            rome_css_syntax::CssSyntaxKind::CSS_KEYFRAMES_SELECTOR,
+        )
+        .variant("CSS_NUMBER", rome_css_syntax::CssSyntaxKind::CSS_NUMBER)
+        .variant(
+            "CSS_PARAMETER",
+            rome_css_syntax::CssSyntaxKind::CSS_PARAMETER,
+        )
+        .variant(
+            "CSS_PERCENTAGE",
+            rome_css_syntax::CssSyntaxKind::CSS_PERCENTAGE,
+        )
+        .variant(
+            "CSS_PSEUDO_CLASS_SELECTOR_PATTERN",
+            rome_css_syntax::CssSyntaxKind::CSS_PSEUDO_CLASS_SELECTOR_PATTERN,
+        )
+        .variant(
+            "CSS_PSEUDO_CLASS_SELECTOR_PATTERN_PARAMETERS",
+            rome_css_syntax::CssSyntaxKind::CSS_PSEUDO_CLASS_SELECTOR_PATTERN_PARAMETERS,
+        )
+        .variant("CSS_RATIO", rome_css_syntax::CssSyntaxKind::CSS_RATIO)
+        .variant(
+            "CSS_SIMPLE_FUNCTION",
+            rome_css_syntax::CssSyntaxKind::CSS_SIMPLE_FUNCTION,
+        )
+        .variant("CSS_STRING", rome_css_syntax::CssSyntaxKind::CSS_STRING)
+        .variant(
+            "CSS_TYPE_SELECTOR_PATTERN",
+            rome_css_syntax::CssSyntaxKind::CSS_TYPE_SELECTOR_PATTERN,
+        )
+        .variant(
+            "CSS_UNIVERSAL_SELECTOR_PATTERN",
+            rome_css_syntax::CssSyntaxKind::CSS_UNIVERSAL_SELECTOR_PATTERN,
+        )
+        .variant(
+            "CSS_VAR_FUNCTION",
+            rome_css_syntax::CssSyntaxKind::CSS_VAR_FUNCTION,
+        )
+        .variant(
+            "CSS_VAR_FUNCTION_VALUE",
+            rome_css_syntax::CssSyntaxKind::CSS_VAR_FUNCTION_VALUE,
+        )
+        .variant(
+            "CSS_ANY_SELECTOR_PATTERN_LIST",
+            rome_css_syntax::CssSyntaxKind::CSS_ANY_SELECTOR_PATTERN_LIST,
+        )
+        .variant(
+            "CSS_AT_KEYFRAMES_ITEM_LIST",
+            rome_css_syntax::CssSyntaxKind::CSS_AT_KEYFRAMES_ITEM_LIST,
+        )
+        .variant(
+            "CSS_AT_MEDIA_QUERY_LIST",
+            rome_css_syntax::CssSyntaxKind::CSS_AT_MEDIA_QUERY_LIST,
+        )
+        .variant(
+            "CSS_ATTRIBUTE_LIST",
+            rome_css_syntax::CssSyntaxKind::CSS_ATTRIBUTE_LIST,
+        )
+        .variant(
+            "CSS_DECLARATION_LIST",
+            rome_css_syntax::CssSyntaxKind::CSS_DECLARATION_LIST,
+        )
+        .variant(
+            "CSS_KEYFRAMES_SELECTOR_LIST",
+            rome_css_syntax::CssSyntaxKind::CSS_KEYFRAMES_SELECTOR_LIST,
+        )
+        .variant(
+            "CSS_PARAMETER_LIST",
+            rome_css_syntax::CssSyntaxKind::CSS_PARAMETER_LIST,
+        )
+        .variant(
+            "CSS_DECLARATION_IMPORTANT",
+            rome_css_syntax::CssSyntaxKind::CSS_DECLARATION_IMPORTANT,
+        )
+        .variant("CSS_BOGUS", rome_css_syntax::CssSyntaxKind::CSS_BOGUS)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAnyFunction>(scope, global, "CssAnyFunction")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(
+            scope,
+            "css_simple_function",
+            CssAnyFunction_css_simple_function,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtKeyframes>(scope, global, "CssAtKeyframes")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "at_token", CssAtKeyframes_at_token)
+        .method(scope, "keyframes_token", CssAtKeyframes_keyframes_token)
+        .method(scope, "name", CssAtKeyframes_name)
+        .method(scope, "css_string", CssAtKeyframes_css_string)
+        .method(scope, "body", CssAtKeyframes_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtKeyframesBody>(scope, global, "CssAtKeyframesBody")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "l_curly_token", CssAtKeyframesBody_l_curly_token)
+        .method(scope, "items", CssAtKeyframesBody_items)
+        .method(scope, "r_curly_token", CssAtKeyframesBody_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtMedia>(scope, global, "CssAtMedia")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "at_token", CssAtMedia_at_token)
+        .method(scope, "media_token", CssAtMedia_media_token)
+        .method(scope, "query_list", CssAtMedia_query_list)
+        .method(scope, "l_curly_token", CssAtMedia_l_curly_token)
+        .method(scope, "body", CssAtMedia_body)
+        .method(scope, "r_curly_token", CssAtMedia_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtMediaQuery>(scope, global, "CssAtMediaQuery")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "condition_token", CssAtMediaQuery_condition_token)
+        .method(scope, "or_token", CssAtMediaQuery_or_token)
+        .method(scope, "only_token", CssAtMediaQuery_only_token)
+        .method(scope, "ty", CssAtMediaQuery_ty)
+        .method(scope, "consequent", CssAtMediaQuery_consequent)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtMediaQueryConsequent>(
+            scope,
+            global,
+            "CssAtMediaQueryConsequent",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "and_token", CssAtMediaQueryConsequent_and_token)
+        .method(
+            scope,
+            "condition_token",
+            CssAtMediaQueryConsequent_condition_token,
+        )
+        .method(scope, "ty", CssAtMediaQueryConsequent_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtMediaQueryFeature>(
+            scope,
+            global,
+            "CssAtMediaQueryFeature",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "l_paren_token", CssAtMediaQueryFeature_l_paren_token)
+        .method(scope, "feature", CssAtMediaQueryFeature_feature)
+        .method(scope, "r_paren_token", CssAtMediaQueryFeature_r_paren_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtMediaQueryFeatureBoolean>(
+            scope,
+            global,
+            "CssAtMediaQueryFeatureBoolean",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(
+            scope,
+            "css_identifier",
+            CssAtMediaQueryFeatureBoolean_css_identifier,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtMediaQueryFeatureCompare>(
+            scope,
+            global,
+            "CssAtMediaQueryFeatureCompare",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "name", CssAtMediaQueryFeatureCompare_name)
+        .method(scope, "range", CssAtMediaQueryFeatureCompare_range)
+        .method(scope, "value", CssAtMediaQueryFeatureCompare_value)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtMediaQueryFeaturePlain>(
+            scope,
+            global,
+            "CssAtMediaQueryFeaturePlain",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "name", CssAtMediaQueryFeaturePlain_name)
+        .method(
+            scope,
+            "colon_token",
+            CssAtMediaQueryFeaturePlain_colon_token,
+        )
+        .method(scope, "value", CssAtMediaQueryFeaturePlain_value)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtMediaQueryFeatureRange>(
+            scope,
+            global,
+            "CssAtMediaQueryFeatureRange",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(
+            scope,
+            "first_value",
+            CssAtMediaQueryFeatureRange_first_value,
+        )
+        .method(
+            scope,
+            "first_range",
+            CssAtMediaQueryFeatureRange_first_range,
+        )
+        .method(scope, "name", CssAtMediaQueryFeatureRange_name)
+        .method(
+            scope,
+            "second_value",
+            CssAtMediaQueryFeatureRange_second_value,
+        )
+        .method(
+            scope,
+            "second_range",
+            CssAtMediaQueryFeatureRange_second_range,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtMediaQueryRange>(scope, global, "CssAtMediaQueryRange")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "r_angle_token", CssAtMediaQueryRange_r_angle_token)
+        .method(scope, "l_angle_token", CssAtMediaQueryRange_l_angle_token)
+        .method(
+            scope,
+            "greater_than_equal_token",
+            CssAtMediaQueryRange_greater_than_equal_token,
+        )
+        .method(
+            scope,
+            "less_than_equal_token",
+            CssAtMediaQueryRange_less_than_equal_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAttribute>(scope, global, "CssAttribute")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "l_brack_token", CssAttribute_l_brack_token)
+        .method(scope, "attribute_name", CssAttribute_attribute_name)
+        .method(scope, "attribute_meta", CssAttribute_attribute_meta)
+        .method(scope, "r_brack_token", CssAttribute_r_brack_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAttributeMatcher>(scope, global, "CssAttributeMatcher")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(
+            scope,
+            "matcher_type_token",
+            CssAttributeMatcher_matcher_type_token,
+        )
+        .method(
+            scope,
+            "exactly_or_hyphen_token",
+            CssAttributeMatcher_exactly_or_hyphen_token,
+        )
+        .method(scope, "prefix_token", CssAttributeMatcher_prefix_token)
+        .method(scope, "suffix_token", CssAttributeMatcher_suffix_token)
+        .method(
+            scope,
+            "times_assign_token",
+            CssAttributeMatcher_times_assign_token,
+        )
+        .method(scope, "eq_token", CssAttributeMatcher_eq_token)
+        .method(scope, "matcher_name", CssAttributeMatcher_matcher_name)
+        .method(scope, "css_identifier", CssAttributeMatcher_css_identifier)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAttributeMeta>(scope, global, "CssAttributeMeta")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(
+            scope,
+            "attribute_matcher",
+            CssAttributeMeta_attribute_matcher,
+        )
+        .method(
+            scope,
+            "attribute_modifier",
+            CssAttributeMeta_attribute_modifier,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAttributeModifier>(scope, global, "CssAttributeModifier")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "i_token", CssAttributeModifier_i_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAttributeName>(scope, global, "CssAttributeName")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "css_string", CssAttributeName_css_string)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAttributeSelectorPattern>(
+            scope,
+            global,
+            "CssAttributeSelectorPattern",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "name", CssAttributeSelectorPattern_name)
+        .method(
+            scope,
+            "attribute_list",
+            CssAttributeSelectorPattern_attribute_list,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssBlock>(scope, global, "CssBlock")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "l_curly_token", CssBlock_l_curly_token)
+        .method(scope, "declaration_list", CssBlock_declaration_list)
+        .method(scope, "r_curly_token", CssBlock_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssClassSelectorPattern>(
+            scope,
+            global,
+            "CssClassSelectorPattern",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "dot_token", CssClassSelectorPattern_dot_token)
+        .method(scope, "name", CssClassSelectorPattern_name)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssCombinatorSelectorPattern>(
+            scope,
+            global,
+            "CssCombinatorSelectorPattern",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "left", CssCombinatorSelectorPattern_left)
+        .method(
+            scope,
+            "combinator_token",
+            CssCombinatorSelectorPattern_combinator_token,
+        )
+        .method(scope, "plus_token", CssCombinatorSelectorPattern_plus_token)
+        .method(
+            scope,
+            "bitwise_not_token",
+            CssCombinatorSelectorPattern_bitwise_not_token,
+        )
+        .method(
+            scope,
+            "css_space_literal_token",
+            CssCombinatorSelectorPattern_css_space_literal_token,
+        )
+        .method(scope, "right", CssCombinatorSelectorPattern_right)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssCustomProperty>(scope, global, "CssCustomProperty")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "value_token", CssCustomProperty_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssDeclaration>(scope, global, "CssDeclaration")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "name", CssDeclaration_name)
+        .method(
+            scope,
+            "css_custom_property",
+            CssDeclaration_css_custom_property,
+        )
+        .method(scope, "colon_token", CssDeclaration_colon_token)
+        .method(scope, "value", CssDeclaration_value)
+        .method(scope, "important", CssDeclaration_important)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssDeclarationImportant>(
+            scope,
+            global,
+            "CssDeclarationImportant",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "excl_token", CssDeclarationImportant_excl_token)
+        .method(
+            scope,
+            "important_token",
+            CssDeclarationImportant_important_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssDimension>(scope, global, "CssDimension")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "value", CssDimension_value)
+        .method(scope, "unit", CssDimension_unit)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssIdSelectorPattern>(scope, global, "CssIdSelectorPattern")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "hash_token", CssIdSelectorPattern_hash_token)
+        .method(scope, "name", CssIdSelectorPattern_name)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssIdentifier>(scope, global, "CssIdentifier")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "value_token", CssIdentifier_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssKeyframesBlock>(scope, global, "CssKeyframesBlock")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "selectors", CssKeyframesBlock_selectors)
+        .method(scope, "l_curly_token", CssKeyframesBlock_l_curly_token)
+        .method(scope, "declarations", CssKeyframesBlock_declarations)
+        .method(scope, "r_curly_token", CssKeyframesBlock_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssKeyframesSelector>(scope, global, "CssKeyframesSelector")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "from_token", CssKeyframesSelector_from_token)
+        .method(scope, "to_token", CssKeyframesSelector_to_token)
+        .method(scope, "css_percentage", CssKeyframesSelector_css_percentage)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssNumber>(scope, global, "CssNumber")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "value_token", CssNumber_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssParameter>(scope, global, "CssParameter")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "any_css_value", CssParameter_any_css_value)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssPercentage>(scope, global, "CssPercentage")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "value", CssPercentage_value)
+        .method(scope, "reminder_token", CssPercentage_reminder_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssPseudoClassSelectorPattern>(
+            scope,
+            global,
+            "CssPseudoClassSelectorPattern",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(
+            scope,
+            "colon_token",
+            CssPseudoClassSelectorPattern_colon_token,
+        )
+        .method(scope, "name", CssPseudoClassSelectorPattern_name)
+        .method(
+            scope,
+            "parameters",
+            CssPseudoClassSelectorPattern_parameters,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssPseudoClassSelectorPatternParameters>(
+            scope,
+            global,
+            "CssPseudoClassSelectorPatternParameters",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(
+            scope,
+            "l_paren_token",
+            CssPseudoClassSelectorPatternParameters_l_paren_token,
+        )
+        .method(
+            scope,
+            "parameter",
+            CssPseudoClassSelectorPatternParameters_parameter,
+        )
+        .method(
+            scope,
+            "r_paren_token",
+            CssPseudoClassSelectorPatternParameters_r_paren_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssRatio>(scope, global, "CssRatio")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "numerator", CssRatio_numerator)
+        .method(scope, "denominator", CssRatio_denominator)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssRoot>(scope, global, "CssRoot")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "rules", CssRoot_rules)
+        .method(scope, "eof_token", CssRoot_eof_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssRule>(scope, global, "CssRule")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "prelude", CssRule_prelude)
+        .method(scope, "block", CssRule_block)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssSelector>(scope, global, "CssSelector")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "pattern_list", CssSelector_pattern_list)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssSimpleFunction>(scope, global, "CssSimpleFunction")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "name", CssSimpleFunction_name)
+        .method(scope, "l_paren_token", CssSimpleFunction_l_paren_token)
+        .method(scope, "items", CssSimpleFunction_items)
+        .method(scope, "r_paren_token", CssSimpleFunction_r_paren_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssString>(scope, global, "CssString")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "value_token", CssString_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssTypeSelectorPattern>(
+            scope,
+            global,
+            "CssTypeSelectorPattern",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "ident", CssTypeSelectorPattern_ident)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssUniversalSelectorPattern>(
+            scope,
+            global,
+            "CssUniversalSelectorPattern",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "star_token", CssUniversalSelectorPattern_star_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssVarFunction>(scope, global, "CssVarFunction")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "var_token", CssVarFunction_var_token)
+        .method(scope, "l_paren_token", CssVarFunction_l_paren_token)
+        .method(scope, "property", CssVarFunction_property)
+        .method(scope, "value", CssVarFunction_value)
+        .method(scope, "r_paren_token", CssVarFunction_r_paren_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssVarFunctionValue>(scope, global, "CssVarFunctionValue")
+        .extends::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>(scope)
+        .method(scope, "comma_token", CssVarFunctionValue_comma_token)
+        .method(scope, "value", CssVarFunctionValue_value)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssBogus>(scope, global, "CssBogus")
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAnySelectorPatternList>(
+            scope,
+            global,
+            "CssAnySelectorPatternList",
+        )
+        .method(scope, "iter", CssAnySelectorPatternList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtKeyframesItemList>(
+            scope,
+            global,
+            "CssAtKeyframesItemList",
+        )
+        .method(scope, "iter", CssAtKeyframesItemList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAtMediaQueryList>(scope, global, "CssAtMediaQueryList")
+        .method(scope, "iter", CssAtMediaQueryList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssAttributeList>(scope, global, "CssAttributeList")
+        .method(scope, "iter", CssAttributeList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssDeclarationList>(scope, global, "CssDeclarationList")
+        .method(scope, "iter", CssDeclarationList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssKeyframesSelectorList>(
+            scope,
+            global,
+            "CssKeyframesSelectorList",
+        )
+        .method(scope, "iter", CssKeyframesSelectorList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssParameterList>(scope, global, "CssParameterList")
+        .method(scope, "iter", CssParameterList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssRuleList>(scope, global, "CssRuleList")
+        .method(scope, "iter", CssRuleList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_css_syntax::CssSelectorList>(scope, global, "CssSelectorList")
+        .method(scope, "iter", CssSelectorList_iter)
+        .finish(scope);
+    registry . build_interface :: < rome_rowan :: AstNodeListIterator < rome_css_syntax :: CssLanguage , rome_css_syntax :: AnyCssRule > > (scope) . iterable (scope , ToV8 :: to_v8) . finish (scope) ;
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_css_syntax::CssLanguage,
+            rome_css_syntax::AnyCssSelectorPattern,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_css_syntax::CssLanguage,
+            rome_css_syntax::CssAtMediaQuery,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry . build_interface :: < rome_rowan :: AstNodeListIterator < rome_css_syntax :: CssLanguage , rome_css_syntax :: CssAttribute > > (scope) . iterable (scope , ToV8 :: to_v8) . finish (scope) ;
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_css_syntax::CssLanguage,
+            rome_css_syntax::CssDeclaration,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_css_syntax::CssLanguage,
+            rome_css_syntax::CssKeyframesBlock,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_css_syntax::CssLanguage,
+            rome_css_syntax::CssKeyframesSelector,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry . build_interface :: < rome_rowan :: AstNodeListIterator < rome_css_syntax :: CssLanguage , rome_css_syntax :: CssParameter > > (scope) . iterable (scope , ToV8 :: to_v8) . finish (scope) ;
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_css_syntax::CssLanguage,
+            rome_css_syntax::CssSelector,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+}
+#[allow(non_snake_case)]
+fn AstSeparatedListNodesIterator_next<'s, T: ToV8<'s>>(
+    item: rome_rowan::SyntaxResult<T>,
+    scope: &mut v8::HandleScope<'s>,
+) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+    ToV8::to_v8(item?, scope)
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAnyFunction {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAnyFunction,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAnyFunction_css_simple_function<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAnyFunction::cast_ref(&*this).unwrap();
+    let result = this.css_simple_function();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAtKeyframes {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAtKeyframes,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtKeyframes_at_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtKeyframes::cast_ref(&*this).unwrap();
+    let result = this.at_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtKeyframes_keyframes_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtKeyframes::cast_ref(&*this).unwrap();
+    let result = this.keyframes_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtKeyframes_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtKeyframes::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtKeyframes_css_string<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtKeyframes::cast_ref(&*this).unwrap();
+    let result = this.css_string();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtKeyframes_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtKeyframes::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAtKeyframesBody {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAtKeyframesBody,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtKeyframesBody_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtKeyframesBody::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtKeyframesBody_items<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtKeyframesBody::cast_ref(&*this).unwrap();
+    let result = this.items();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn CssAtKeyframesBody_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtKeyframesBody::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAtMedia {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAtMedia,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMedia_at_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMedia::cast_ref(&*this).unwrap();
+    let result = this.at_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMedia_media_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMedia::cast_ref(&*this).unwrap();
+    let result = this.media_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMedia_query_list<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMedia::cast_ref(&*this).unwrap();
+    let result = this.query_list();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn CssAtMedia_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMedia::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMedia_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMedia::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMedia_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMedia::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAtMediaQuery {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAtMediaQuery,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQuery_condition_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQuery::cast_ref(&*this).unwrap();
+    let result = this.condition_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQuery_or_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQuery::cast_ref(&*this).unwrap();
+    let result = this.or_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQuery_only_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQuery::cast_ref(&*this).unwrap();
+    let result = this.only_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQuery_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQuery::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQuery_consequent<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQuery::cast_ref(&*this).unwrap();
+    let result = this.consequent();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAtMediaQueryConsequent {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAtMediaQueryConsequent,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryConsequent_and_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryConsequent::cast_ref(&*this).unwrap();
+    let result = this.and_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryConsequent_condition_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryConsequent::cast_ref(&*this).unwrap();
+    let result = this.condition_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryConsequent_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryConsequent::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAtMediaQueryFeature {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAtMediaQueryFeature,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeature_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeature::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeature_feature<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeature::cast_ref(&*this).unwrap();
+    let result = this.feature();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeature_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeature::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAtMediaQueryFeatureBoolean {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAtMediaQueryFeatureBoolean,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeatureBoolean_css_identifier<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeatureBoolean::cast_ref(&*this).unwrap();
+    let result = this.css_identifier();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAtMediaQueryFeatureCompare {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAtMediaQueryFeatureCompare,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeatureCompare_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeatureCompare::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeatureCompare_range<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeatureCompare::cast_ref(&*this).unwrap();
+    let result = this.range();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeatureCompare_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeatureCompare::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAtMediaQueryFeaturePlain {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAtMediaQueryFeaturePlain,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeaturePlain_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeaturePlain::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeaturePlain_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeaturePlain::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeaturePlain_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeaturePlain::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAtMediaQueryFeatureRange {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAtMediaQueryFeatureRange,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeatureRange_first_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeatureRange::cast_ref(&*this).unwrap();
+    let result = this.first_value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeatureRange_first_range<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeatureRange::cast_ref(&*this).unwrap();
+    let result = this.first_range();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeatureRange_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeatureRange::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeatureRange_second_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeatureRange::cast_ref(&*this).unwrap();
+    let result = this.second_value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryFeatureRange_second_range<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryFeatureRange::cast_ref(&*this).unwrap();
+    let result = this.second_range();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAtMediaQueryRange {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAtMediaQueryRange,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryRange_r_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryRange::cast_ref(&*this).unwrap();
+    let result = this.r_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryRange_l_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryRange::cast_ref(&*this).unwrap();
+    let result = this.l_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryRange_greater_than_equal_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryRange::cast_ref(&*this).unwrap();
+    let result = this.greater_than_equal_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAtMediaQueryRange_less_than_equal_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAtMediaQueryRange::cast_ref(&*this).unwrap();
+    let result = this.less_than_equal_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAttribute {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAttribute,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttribute_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttribute::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttribute_attribute_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttribute::cast_ref(&*this).unwrap();
+    let result = this.attribute_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttribute_attribute_meta<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttribute::cast_ref(&*this).unwrap();
+    let result = this.attribute_meta();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttribute_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttribute::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAttributeMatcher {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAttributeMatcher,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeMatcher_matcher_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeMatcher::cast_ref(&*this).unwrap();
+    let result = this.matcher_type_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeMatcher_exactly_or_hyphen_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeMatcher::cast_ref(&*this).unwrap();
+    let result = this.exactly_or_hyphen_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeMatcher_prefix_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeMatcher::cast_ref(&*this).unwrap();
+    let result = this.prefix_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeMatcher_suffix_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeMatcher::cast_ref(&*this).unwrap();
+    let result = this.suffix_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeMatcher_times_assign_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeMatcher::cast_ref(&*this).unwrap();
+    let result = this.times_assign_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeMatcher_eq_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeMatcher::cast_ref(&*this).unwrap();
+    let result = this.eq_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeMatcher_matcher_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeMatcher::cast_ref(&*this).unwrap();
+    let result = this.matcher_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeMatcher_css_identifier<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeMatcher::cast_ref(&*this).unwrap();
+    let result = this.css_identifier();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAttributeMeta {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAttributeMeta,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeMeta_attribute_matcher<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeMeta::cast_ref(&*this).unwrap();
+    let result = this.attribute_matcher();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeMeta_attribute_modifier<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeMeta::cast_ref(&*this).unwrap();
+    let result = this.attribute_modifier();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAttributeModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAttributeModifier,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeModifier_i_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeModifier::cast_ref(&*this).unwrap();
+    let result = this.i_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAttributeName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAttributeName,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeName_css_string<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeName::cast_ref(&*this).unwrap();
+    let result = this.css_string();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssAttributeSelectorPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssAttributeSelectorPattern,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeSelectorPattern_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssAttributeSelectorPattern_attribute_list<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssAttributeSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.attribute_list();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssBlock {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssBlock,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssBlock_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssBlock::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssBlock_declaration_list<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssBlock::cast_ref(&*this).unwrap();
+    let result = this.declaration_list();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn CssBlock_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssBlock::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssClassSelectorPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssClassSelectorPattern,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssClassSelectorPattern_dot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssClassSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.dot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssClassSelectorPattern_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssClassSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssCombinatorSelectorPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssCombinatorSelectorPattern,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssCombinatorSelectorPattern_left<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssCombinatorSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.left();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssCombinatorSelectorPattern_combinator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssCombinatorSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.combinator_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssCombinatorSelectorPattern_plus_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssCombinatorSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.plus_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssCombinatorSelectorPattern_bitwise_not_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssCombinatorSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.bitwise_not_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssCombinatorSelectorPattern_css_space_literal_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssCombinatorSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.css_space_literal_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssCombinatorSelectorPattern_right<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssCombinatorSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.right();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssCustomProperty {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssCustomProperty,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssCustomProperty_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssCustomProperty::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssDeclaration,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssDeclaration_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssDeclaration::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssDeclaration_css_custom_property<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssDeclaration::cast_ref(&*this).unwrap();
+    let result = this.css_custom_property();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssDeclaration_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssDeclaration::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssDeclaration_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssDeclaration::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssDeclaration_important<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssDeclaration::cast_ref(&*this).unwrap();
+    let result = this.important();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssDeclarationImportant {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssDeclarationImportant,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssDeclarationImportant_excl_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssDeclarationImportant::cast_ref(&*this).unwrap();
+    let result = this.excl_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssDeclarationImportant_important_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssDeclarationImportant::cast_ref(&*this).unwrap();
+    let result = this.important_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssDimension {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssDimension,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssDimension_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssDimension::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssDimension_unit<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssDimension::cast_ref(&*this).unwrap();
+    let result = this.unit();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssIdSelectorPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssIdSelectorPattern,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssIdSelectorPattern_hash_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssIdSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.hash_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssIdSelectorPattern_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssIdSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssIdentifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssIdentifier,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssIdentifier_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssIdentifier::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssKeyframesBlock {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssKeyframesBlock,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssKeyframesBlock_selectors<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssKeyframesBlock::cast_ref(&*this).unwrap();
+    let result = this.selectors();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn CssKeyframesBlock_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssKeyframesBlock::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssKeyframesBlock_declarations<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssKeyframesBlock::cast_ref(&*this).unwrap();
+    let result = this.declarations();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn CssKeyframesBlock_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssKeyframesBlock::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssKeyframesSelector {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssKeyframesSelector,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssKeyframesSelector_from_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssKeyframesSelector::cast_ref(&*this).unwrap();
+    let result = this.from_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssKeyframesSelector_to_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssKeyframesSelector::cast_ref(&*this).unwrap();
+    let result = this.to_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssKeyframesSelector_css_percentage<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssKeyframesSelector::cast_ref(&*this).unwrap();
+    let result = this.css_percentage();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssNumber {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssNumber,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssNumber_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssNumber::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssParameter {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssParameter,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssParameter_any_css_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssParameter::cast_ref(&*this).unwrap();
+    let result = this.any_css_value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssPercentage {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssPercentage,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssPercentage_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssPercentage::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssPercentage_reminder_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssPercentage::cast_ref(&*this).unwrap();
+    let result = this.reminder_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssPseudoClassSelectorPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssPseudoClassSelectorPattern,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssPseudoClassSelectorPattern_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssPseudoClassSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssPseudoClassSelectorPattern_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssPseudoClassSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssPseudoClassSelectorPattern_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssPseudoClassSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssPseudoClassSelectorPatternParameters {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssPseudoClassSelectorPatternParameters,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssPseudoClassSelectorPatternParameters_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssPseudoClassSelectorPatternParameters::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssPseudoClassSelectorPatternParameters_parameter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssPseudoClassSelectorPatternParameters::cast_ref(&*this).unwrap();
+    let result = this.parameter();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssPseudoClassSelectorPatternParameters_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssPseudoClassSelectorPatternParameters::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssRatio {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssRatio,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssRatio_numerator<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssRatio::cast_ref(&*this).unwrap();
+    let result = this.numerator();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssRatio_denominator<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssRatio::cast_ref(&*this).unwrap();
+    let result = this.denominator();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssRoot {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssRoot,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssRoot_rules<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssRoot::cast_ref(&*this).unwrap();
+    let result = this.rules();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn CssRoot_eof_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssRoot::cast_ref(&*this).unwrap();
+    let result = this.eof_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssRule {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssRule,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssRule_prelude<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssRule::cast_ref(&*this).unwrap();
+    let result = this.prelude();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn CssRule_block<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssRule::cast_ref(&*this).unwrap();
+    let result = this.block();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssSelector {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssSelector,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssSelector_pattern_list<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssSelector::cast_ref(&*this).unwrap();
+    let result = this.pattern_list();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssSimpleFunction {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssSimpleFunction,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssSimpleFunction_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssSimpleFunction::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssSimpleFunction_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssSimpleFunction::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssSimpleFunction_items<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssSimpleFunction::cast_ref(&*this).unwrap();
+    let result = this.items();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn CssSimpleFunction_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssSimpleFunction::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssString {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssString,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssString_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssString::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssTypeSelectorPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssTypeSelectorPattern,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssTypeSelectorPattern_ident<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssTypeSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.ident();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssUniversalSelectorPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssUniversalSelectorPattern,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssUniversalSelectorPattern_star_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssUniversalSelectorPattern::cast_ref(&*this).unwrap();
+    let result = this.star_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssVarFunction {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssVarFunction,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssVarFunction_var_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssVarFunction::cast_ref(&*this).unwrap();
+    let result = this.var_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssVarFunction_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssVarFunction::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssVarFunction_property<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssVarFunction::cast_ref(&*this).unwrap();
+    let result = this.property();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssVarFunction_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssVarFunction::cast_ref(&*this).unwrap();
+    let result = this.value();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn CssVarFunction_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssVarFunction::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::CssVarFunctionValue {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_css_syntax::CssVarFunctionValue,
+            rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn CssVarFunctionValue_comma_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssVarFunctionValue::cast_ref(&*this).unwrap();
+    let result = this.comma_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn CssVarFunctionValue_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_css_syntax::CssLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_css_syntax::CssVarFunctionValue::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::AnyCssAtMediaQueryFeatureType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::CssAtMediaQueryFeatureBoolean(node) => ToV8::to_v8(node, scope),
+            Self::CssAtMediaQueryFeatureCompare(node) => ToV8::to_v8(node, scope),
+            Self::CssAtMediaQueryFeaturePlain(node) => ToV8::to_v8(node, scope),
+            Self::CssAtMediaQueryFeatureRange(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::AnyCssAtMediaQueryType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::CssAtMediaQueryFeature(node) => ToV8::to_v8(node, scope),
+            Self::CssIdentifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::AnyCssAtRule {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::CssAtKeyframes(node) => ToV8::to_v8(node, scope),
+            Self::CssAtMedia(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::AnyCssRule {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyCssAtRule(node) => ToV8::to_v8(node, scope),
+            Self::CssRule(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::AnyCssSelectorPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::CssAttributeSelectorPattern(node) => ToV8::to_v8(node, scope),
+            Self::CssClassSelectorPattern(node) => ToV8::to_v8(node, scope),
+            Self::CssCombinatorSelectorPattern(node) => ToV8::to_v8(node, scope),
+            Self::CssIdSelectorPattern(node) => ToV8::to_v8(node, scope),
+            Self::CssPseudoClassSelectorPattern(node) => ToV8::to_v8(node, scope),
+            Self::CssTypeSelectorPattern(node) => ToV8::to_v8(node, scope),
+            Self::CssUniversalSelectorPattern(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_css_syntax::AnyCssValue {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::CssAnyFunction(node) => ToV8::to_v8(node, scope),
+            Self::CssCustomProperty(node) => ToV8::to_v8(node, scope),
+            Self::CssDimension(node) => ToV8::to_v8(node, scope),
+            Self::CssIdentifier(node) => ToV8::to_v8(node, scope),
+            Self::CssNumber(node) => ToV8::to_v8(node, scope),
+            Self::CssRatio(node) => ToV8::to_v8(node, scope),
+            Self::CssString(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+crate::convert::impl_convert_native!(rome_css_syntax::CssBogus);
+crate::convert::impl_convert_native!(rome_css_syntax::CssAnySelectorPatternList);
+#[allow(non_snake_case)]
+fn CssAnySelectorPatternList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_css_syntax::CssAnySelectorPatternList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_css_syntax::CssAtKeyframesItemList);
+#[allow(non_snake_case)]
+fn CssAtKeyframesItemList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_css_syntax::CssAtKeyframesItemList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_css_syntax::CssAtMediaQueryList);
+#[allow(non_snake_case)]
+fn CssAtMediaQueryList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_css_syntax::CssAtMediaQueryList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_css_syntax::CssAttributeList);
+#[allow(non_snake_case)]
+fn CssAttributeList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_css_syntax::CssAttributeList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_css_syntax::CssDeclarationList);
+#[allow(non_snake_case)]
+fn CssDeclarationList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_css_syntax::CssDeclarationList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_css_syntax::CssKeyframesSelectorList);
+#[allow(non_snake_case)]
+fn CssKeyframesSelectorList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_css_syntax::CssKeyframesSelectorList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_css_syntax::CssParameterList);
+#[allow(non_snake_case)]
+fn CssParameterList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_css_syntax::CssParameterList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_css_syntax::CssRuleList);
+#[allow(non_snake_case)]
+fn CssRuleList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_css_syntax::CssRuleList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_css_syntax::CssSelectorList);
+#[allow(non_snake_case)]
+fn CssSelectorList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_css_syntax::CssSelectorList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_css_syntax :: CssLanguage , rome_css_syntax :: AnyCssRule >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_css_syntax :: CssLanguage , rome_css_syntax :: AnyCssSelectorPattern >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_css_syntax :: CssLanguage , rome_css_syntax :: CssAtMediaQuery >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_css_syntax :: CssLanguage , rome_css_syntax :: CssAttribute >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_css_syntax :: CssLanguage , rome_css_syntax :: CssDeclaration >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_css_syntax :: CssLanguage , rome_css_syntax :: CssKeyframesBlock >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_css_syntax :: CssLanguage , rome_css_syntax :: CssKeyframesSelector >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_css_syntax :: CssLanguage , rome_css_syntax :: CssParameter >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_css_syntax :: CssLanguage , rome_css_syntax :: CssSelector >);
diff --git a/crates/rome_v8/src/bindings/js.rs b/crates/rome_v8/src/bindings/js.rs
new file mode 100644
index 00000000000..2fb683b2af5
--- /dev/null
+++ b/crates/rome_v8/src/bindings/js.rs
@@ -0,0 +1,30390 @@
+//! Generated file, do not edit by hand, see `xtask/codegen`
+
+use super::TemplateRegistry;
+use crate::convert::{FromV8, ToV8};
+use rome_rowan::{AstNode as _, AstNodeList as _, AstSeparatedList as _};
+pub(super) fn register_interfaces(
+    scope: &mut v8::HandleScope<'_, ()>,
+    global: v8::Local<'_, v8::ObjectTemplate>,
+    registry: &mut TemplateRegistry,
+) {
+    registry
+        .build_enum::<rome_js_syntax::JsSyntaxKind>(scope, global, "JsSyntaxKind")
+        .variant("EOF", rome_js_syntax::JsSyntaxKind::EOF)
+        .variant("SEMICOLON", rome_js_syntax::JsSyntaxKind::SEMICOLON)
+        .variant("COMMA", rome_js_syntax::JsSyntaxKind::COMMA)
+        .variant("L_PAREN", rome_js_syntax::JsSyntaxKind::L_PAREN)
+        .variant("R_PAREN", rome_js_syntax::JsSyntaxKind::R_PAREN)
+        .variant("L_CURLY", rome_js_syntax::JsSyntaxKind::L_CURLY)
+        .variant("R_CURLY", rome_js_syntax::JsSyntaxKind::R_CURLY)
+        .variant("L_BRACK", rome_js_syntax::JsSyntaxKind::L_BRACK)
+        .variant("R_BRACK", rome_js_syntax::JsSyntaxKind::R_BRACK)
+        .variant("L_ANGLE", rome_js_syntax::JsSyntaxKind::L_ANGLE)
+        .variant("R_ANGLE", rome_js_syntax::JsSyntaxKind::R_ANGLE)
+        .variant("TILDE", rome_js_syntax::JsSyntaxKind::TILDE)
+        .variant("QUESTION", rome_js_syntax::JsSyntaxKind::QUESTION)
+        .variant("QUESTION2", rome_js_syntax::JsSyntaxKind::QUESTION2)
+        .variant("QUESTIONDOT", rome_js_syntax::JsSyntaxKind::QUESTIONDOT)
+        .variant("AMP", rome_js_syntax::JsSyntaxKind::AMP)
+        .variant("PIPE", rome_js_syntax::JsSyntaxKind::PIPE)
+        .variant("PLUS", rome_js_syntax::JsSyntaxKind::PLUS)
+        .variant("PLUS2", rome_js_syntax::JsSyntaxKind::PLUS2)
+        .variant("STAR", rome_js_syntax::JsSyntaxKind::STAR)
+        .variant("STAR2", rome_js_syntax::JsSyntaxKind::STAR2)
+        .variant("SLASH", rome_js_syntax::JsSyntaxKind::SLASH)
+        .variant("CARET", rome_js_syntax::JsSyntaxKind::CARET)
+        .variant("PERCENT", rome_js_syntax::JsSyntaxKind::PERCENT)
+        .variant("DOT", rome_js_syntax::JsSyntaxKind::DOT)
+        .variant("DOT3", rome_js_syntax::JsSyntaxKind::DOT3)
+        .variant("COLON", rome_js_syntax::JsSyntaxKind::COLON)
+        .variant("EQ", rome_js_syntax::JsSyntaxKind::EQ)
+        .variant("EQ2", rome_js_syntax::JsSyntaxKind::EQ2)
+        .variant("EQ3", rome_js_syntax::JsSyntaxKind::EQ3)
+        .variant("FAT_ARROW", rome_js_syntax::JsSyntaxKind::FAT_ARROW)
+        .variant("BANG", rome_js_syntax::JsSyntaxKind::BANG)
+        .variant("NEQ", rome_js_syntax::JsSyntaxKind::NEQ)
+        .variant("NEQ2", rome_js_syntax::JsSyntaxKind::NEQ2)
+        .variant("MINUS", rome_js_syntax::JsSyntaxKind::MINUS)
+        .variant("MINUS2", rome_js_syntax::JsSyntaxKind::MINUS2)
+        .variant("LTEQ", rome_js_syntax::JsSyntaxKind::LTEQ)
+        .variant("GTEQ", rome_js_syntax::JsSyntaxKind::GTEQ)
+        .variant("PLUSEQ", rome_js_syntax::JsSyntaxKind::PLUSEQ)
+        .variant("MINUSEQ", rome_js_syntax::JsSyntaxKind::MINUSEQ)
+        .variant("PIPEEQ", rome_js_syntax::JsSyntaxKind::PIPEEQ)
+        .variant("AMPEQ", rome_js_syntax::JsSyntaxKind::AMPEQ)
+        .variant("CARETEQ", rome_js_syntax::JsSyntaxKind::CARETEQ)
+        .variant("SLASHEQ", rome_js_syntax::JsSyntaxKind::SLASHEQ)
+        .variant("STAREQ", rome_js_syntax::JsSyntaxKind::STAREQ)
+        .variant("PERCENTEQ", rome_js_syntax::JsSyntaxKind::PERCENTEQ)
+        .variant("AMP2", rome_js_syntax::JsSyntaxKind::AMP2)
+        .variant("PIPE2", rome_js_syntax::JsSyntaxKind::PIPE2)
+        .variant("SHL", rome_js_syntax::JsSyntaxKind::SHL)
+        .variant("SHR", rome_js_syntax::JsSyntaxKind::SHR)
+        .variant("USHR", rome_js_syntax::JsSyntaxKind::USHR)
+        .variant("SHLEQ", rome_js_syntax::JsSyntaxKind::SHLEQ)
+        .variant("SHREQ", rome_js_syntax::JsSyntaxKind::SHREQ)
+        .variant("USHREQ", rome_js_syntax::JsSyntaxKind::USHREQ)
+        .variant("AMP2EQ", rome_js_syntax::JsSyntaxKind::AMP2EQ)
+        .variant("PIPE2EQ", rome_js_syntax::JsSyntaxKind::PIPE2EQ)
+        .variant("STAR2EQ", rome_js_syntax::JsSyntaxKind::STAR2EQ)
+        .variant("QUESTION2EQ", rome_js_syntax::JsSyntaxKind::QUESTION2EQ)
+        .variant("AT", rome_js_syntax::JsSyntaxKind::AT)
+        .variant("BACKTICK", rome_js_syntax::JsSyntaxKind::BACKTICK)
+        .variant("BREAK_KW", rome_js_syntax::JsSyntaxKind::BREAK_KW)
+        .variant("CASE_KW", rome_js_syntax::JsSyntaxKind::CASE_KW)
+        .variant("CATCH_KW", rome_js_syntax::JsSyntaxKind::CATCH_KW)
+        .variant("CLASS_KW", rome_js_syntax::JsSyntaxKind::CLASS_KW)
+        .variant("CONST_KW", rome_js_syntax::JsSyntaxKind::CONST_KW)
+        .variant("CONTINUE_KW", rome_js_syntax::JsSyntaxKind::CONTINUE_KW)
+        .variant("DEBUGGER_KW", rome_js_syntax::JsSyntaxKind::DEBUGGER_KW)
+        .variant("DEFAULT_KW", rome_js_syntax::JsSyntaxKind::DEFAULT_KW)
+        .variant("DELETE_KW", rome_js_syntax::JsSyntaxKind::DELETE_KW)
+        .variant("DO_KW", rome_js_syntax::JsSyntaxKind::DO_KW)
+        .variant("ELSE_KW", rome_js_syntax::JsSyntaxKind::ELSE_KW)
+        .variant("ENUM_KW", rome_js_syntax::JsSyntaxKind::ENUM_KW)
+        .variant("EXPORT_KW", rome_js_syntax::JsSyntaxKind::EXPORT_KW)
+        .variant("EXTENDS_KW", rome_js_syntax::JsSyntaxKind::EXTENDS_KW)
+        .variant("FALSE_KW", rome_js_syntax::JsSyntaxKind::FALSE_KW)
+        .variant("FINALLY_KW", rome_js_syntax::JsSyntaxKind::FINALLY_KW)
+        .variant("FOR_KW", rome_js_syntax::JsSyntaxKind::FOR_KW)
+        .variant("FUNCTION_KW", rome_js_syntax::JsSyntaxKind::FUNCTION_KW)
+        .variant("IF_KW", rome_js_syntax::JsSyntaxKind::IF_KW)
+        .variant("IN_KW", rome_js_syntax::JsSyntaxKind::IN_KW)
+        .variant("INSTANCEOF_KW", rome_js_syntax::JsSyntaxKind::INSTANCEOF_KW)
+        .variant("IMPORT_KW", rome_js_syntax::JsSyntaxKind::IMPORT_KW)
+        .variant("NEW_KW", rome_js_syntax::JsSyntaxKind::NEW_KW)
+        .variant("NULL_KW", rome_js_syntax::JsSyntaxKind::NULL_KW)
+        .variant("RETURN_KW", rome_js_syntax::JsSyntaxKind::RETURN_KW)
+        .variant("SUPER_KW", rome_js_syntax::JsSyntaxKind::SUPER_KW)
+        .variant("SWITCH_KW", rome_js_syntax::JsSyntaxKind::SWITCH_KW)
+        .variant("THIS_KW", rome_js_syntax::JsSyntaxKind::THIS_KW)
+        .variant("THROW_KW", rome_js_syntax::JsSyntaxKind::THROW_KW)
+        .variant("TRY_KW", rome_js_syntax::JsSyntaxKind::TRY_KW)
+        .variant("TRUE_KW", rome_js_syntax::JsSyntaxKind::TRUE_KW)
+        .variant("TYPEOF_KW", rome_js_syntax::JsSyntaxKind::TYPEOF_KW)
+        .variant("VAR_KW", rome_js_syntax::JsSyntaxKind::VAR_KW)
+        .variant("VOID_KW", rome_js_syntax::JsSyntaxKind::VOID_KW)
+        .variant("WHILE_KW", rome_js_syntax::JsSyntaxKind::WHILE_KW)
+        .variant("WITH_KW", rome_js_syntax::JsSyntaxKind::WITH_KW)
+        .variant("IMPLEMENTS_KW", rome_js_syntax::JsSyntaxKind::IMPLEMENTS_KW)
+        .variant("INTERFACE_KW", rome_js_syntax::JsSyntaxKind::INTERFACE_KW)
+        .variant("LET_KW", rome_js_syntax::JsSyntaxKind::LET_KW)
+        .variant("PACKAGE_KW", rome_js_syntax::JsSyntaxKind::PACKAGE_KW)
+        .variant("PRIVATE_KW", rome_js_syntax::JsSyntaxKind::PRIVATE_KW)
+        .variant("PROTECTED_KW", rome_js_syntax::JsSyntaxKind::PROTECTED_KW)
+        .variant("PUBLIC_KW", rome_js_syntax::JsSyntaxKind::PUBLIC_KW)
+        .variant("STATIC_KW", rome_js_syntax::JsSyntaxKind::STATIC_KW)
+        .variant("YIELD_KW", rome_js_syntax::JsSyntaxKind::YIELD_KW)
+        .variant("ABSTRACT_KW", rome_js_syntax::JsSyntaxKind::ABSTRACT_KW)
+        .variant("ACCESSOR_KW", rome_js_syntax::JsSyntaxKind::ACCESSOR_KW)
+        .variant("AS_KW", rome_js_syntax::JsSyntaxKind::AS_KW)
+        .variant("SATISFIES_KW", rome_js_syntax::JsSyntaxKind::SATISFIES_KW)
+        .variant("ASSERTS_KW", rome_js_syntax::JsSyntaxKind::ASSERTS_KW)
+        .variant("ASSERT_KW", rome_js_syntax::JsSyntaxKind::ASSERT_KW)
+        .variant("ANY_KW", rome_js_syntax::JsSyntaxKind::ANY_KW)
+        .variant("ASYNC_KW", rome_js_syntax::JsSyntaxKind::ASYNC_KW)
+        .variant("AWAIT_KW", rome_js_syntax::JsSyntaxKind::AWAIT_KW)
+        .variant("BOOLEAN_KW", rome_js_syntax::JsSyntaxKind::BOOLEAN_KW)
+        .variant(
+            "CONSTRUCTOR_KW",
+            rome_js_syntax::JsSyntaxKind::CONSTRUCTOR_KW,
+        )
+        .variant("DECLARE_KW", rome_js_syntax::JsSyntaxKind::DECLARE_KW)
+        .variant("GET_KW", rome_js_syntax::JsSyntaxKind::GET_KW)
+        .variant("INFER_KW", rome_js_syntax::JsSyntaxKind::INFER_KW)
+        .variant("IS_KW", rome_js_syntax::JsSyntaxKind::IS_KW)
+        .variant("KEYOF_KW", rome_js_syntax::JsSyntaxKind::KEYOF_KW)
+        .variant("MODULE_KW", rome_js_syntax::JsSyntaxKind::MODULE_KW)
+        .variant("NAMESPACE_KW", rome_js_syntax::JsSyntaxKind::NAMESPACE_KW)
+        .variant("NEVER_KW", rome_js_syntax::JsSyntaxKind::NEVER_KW)
+        .variant("READONLY_KW", rome_js_syntax::JsSyntaxKind::READONLY_KW)
+        .variant("REQUIRE_KW", rome_js_syntax::JsSyntaxKind::REQUIRE_KW)
+        .variant("NUMBER_KW", rome_js_syntax::JsSyntaxKind::NUMBER_KW)
+        .variant("OBJECT_KW", rome_js_syntax::JsSyntaxKind::OBJECT_KW)
+        .variant("SET_KW", rome_js_syntax::JsSyntaxKind::SET_KW)
+        .variant("STRING_KW", rome_js_syntax::JsSyntaxKind::STRING_KW)
+        .variant("SYMBOL_KW", rome_js_syntax::JsSyntaxKind::SYMBOL_KW)
+        .variant("TYPE_KW", rome_js_syntax::JsSyntaxKind::TYPE_KW)
+        .variant("UNDEFINED_KW", rome_js_syntax::JsSyntaxKind::UNDEFINED_KW)
+        .variant("UNIQUE_KW", rome_js_syntax::JsSyntaxKind::UNIQUE_KW)
+        .variant("UNKNOWN_KW", rome_js_syntax::JsSyntaxKind::UNKNOWN_KW)
+        .variant("FROM_KW", rome_js_syntax::JsSyntaxKind::FROM_KW)
+        .variant("GLOBAL_KW", rome_js_syntax::JsSyntaxKind::GLOBAL_KW)
+        .variant("BIGINT_KW", rome_js_syntax::JsSyntaxKind::BIGINT_KW)
+        .variant("OVERRIDE_KW", rome_js_syntax::JsSyntaxKind::OVERRIDE_KW)
+        .variant("OF_KW", rome_js_syntax::JsSyntaxKind::OF_KW)
+        .variant("OUT_KW", rome_js_syntax::JsSyntaxKind::OUT_KW)
+        .variant(
+            "JS_NUMBER_LITERAL",
+            rome_js_syntax::JsSyntaxKind::JS_NUMBER_LITERAL,
+        )
+        .variant(
+            "JS_BIGINT_LITERAL",
+            rome_js_syntax::JsSyntaxKind::JS_BIGINT_LITERAL,
+        )
+        .variant(
+            "JS_STRING_LITERAL",
+            rome_js_syntax::JsSyntaxKind::JS_STRING_LITERAL,
+        )
+        .variant(
+            "JS_REGEX_LITERAL",
+            rome_js_syntax::JsSyntaxKind::JS_REGEX_LITERAL,
+        )
+        .variant(
+            "JSX_TEXT_LITERAL",
+            rome_js_syntax::JsSyntaxKind::JSX_TEXT_LITERAL,
+        )
+        .variant(
+            "JSX_STRING_LITERAL",
+            rome_js_syntax::JsSyntaxKind::JSX_STRING_LITERAL,
+        )
+        .variant("TARGET", rome_js_syntax::JsSyntaxKind::TARGET)
+        .variant("META", rome_js_syntax::JsSyntaxKind::META)
+        .variant("HASH", rome_js_syntax::JsSyntaxKind::HASH)
+        .variant(
+            "TEMPLATE_CHUNK",
+            rome_js_syntax::JsSyntaxKind::TEMPLATE_CHUNK,
+        )
+        .variant("DOLLAR_CURLY", rome_js_syntax::JsSyntaxKind::DOLLAR_CURLY)
+        .variant("ERROR_TOKEN", rome_js_syntax::JsSyntaxKind::ERROR_TOKEN)
+        .variant("IDENT", rome_js_syntax::JsSyntaxKind::IDENT)
+        .variant("JSX_IDENT", rome_js_syntax::JsSyntaxKind::JSX_IDENT)
+        .variant("NEWLINE", rome_js_syntax::JsSyntaxKind::NEWLINE)
+        .variant("WHITESPACE", rome_js_syntax::JsSyntaxKind::WHITESPACE)
+        .variant("COMMENT", rome_js_syntax::JsSyntaxKind::COMMENT)
+        .variant(
+            "MULTILINE_COMMENT",
+            rome_js_syntax::JsSyntaxKind::MULTILINE_COMMENT,
+        )
+        .variant("JS_SHEBANG", rome_js_syntax::JsSyntaxKind::JS_SHEBANG)
+        .variant("JS_MODULE", rome_js_syntax::JsSyntaxKind::JS_MODULE)
+        .variant(
+            "JS_MODULE_ITEM_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_MODULE_ITEM_LIST,
+        )
+        .variant("JS_SCRIPT", rome_js_syntax::JsSyntaxKind::JS_SCRIPT)
+        .variant(
+            "JS_EXPRESSION_SNIPPED",
+            rome_js_syntax::JsSyntaxKind::JS_EXPRESSION_SNIPPED,
+        )
+        .variant("JS_DIRECTIVE", rome_js_syntax::JsSyntaxKind::JS_DIRECTIVE)
+        .variant(
+            "JS_DIRECTIVE_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_DIRECTIVE_LIST,
+        )
+        .variant(
+            "JS_STATEMENT_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_STATEMENT_LIST,
+        )
+        .variant(
+            "JS_BLOCK_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_BLOCK_STATEMENT,
+        )
+        .variant(
+            "JS_FUNCTION_BODY",
+            rome_js_syntax::JsSyntaxKind::JS_FUNCTION_BODY,
+        )
+        .variant(
+            "JS_VARIABLE_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_VARIABLE_STATEMENT,
+        )
+        .variant(
+            "JS_VARIABLE_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::JS_VARIABLE_DECLARATION,
+        )
+        .variant(
+            "JS_VARIABLE_DECLARATOR_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_VARIABLE_DECLARATOR_LIST,
+        )
+        .variant(
+            "JS_VARIABLE_DECLARATOR",
+            rome_js_syntax::JsSyntaxKind::JS_VARIABLE_DECLARATOR,
+        )
+        .variant(
+            "JS_VARIABLE_DECLARATION_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_VARIABLE_DECLARATION_CLAUSE,
+        )
+        .variant(
+            "TS_DEFINITE_VARIABLE_ANNOTATION",
+            rome_js_syntax::JsSyntaxKind::TS_DEFINITE_VARIABLE_ANNOTATION,
+        )
+        .variant(
+            "JS_INITIALIZER_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_INITIALIZER_CLAUSE,
+        )
+        .variant(
+            "JS_EMPTY_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_EMPTY_STATEMENT,
+        )
+        .variant(
+            "JS_EXPRESSION_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_EXPRESSION_STATEMENT,
+        )
+        .variant(
+            "JS_IF_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_IF_STATEMENT,
+        )
+        .variant(
+            "JS_ELSE_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_ELSE_CLAUSE,
+        )
+        .variant(
+            "JS_DO_WHILE_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_DO_WHILE_STATEMENT,
+        )
+        .variant(
+            "JS_WHILE_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_WHILE_STATEMENT,
+        )
+        .variant(
+            "JS_FOR_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_FOR_STATEMENT,
+        )
+        .variant(
+            "JS_FOR_IN_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_FOR_IN_STATEMENT,
+        )
+        .variant(
+            "JS_FOR_OF_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_FOR_OF_STATEMENT,
+        )
+        .variant(
+            "JS_FOR_VARIABLE_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::JS_FOR_VARIABLE_DECLARATION,
+        )
+        .variant(
+            "JS_CONTINUE_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_CONTINUE_STATEMENT,
+        )
+        .variant(
+            "JS_BREAK_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_BREAK_STATEMENT,
+        )
+        .variant(
+            "JS_RETURN_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_RETURN_STATEMENT,
+        )
+        .variant(
+            "JS_WITH_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_WITH_STATEMENT,
+        )
+        .variant(
+            "JS_SWITCH_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_SWITCH_STATEMENT,
+        )
+        .variant(
+            "JS_SWITCH_CASE_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_SWITCH_CASE_LIST,
+        )
+        .variant(
+            "JS_CASE_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_CASE_CLAUSE,
+        )
+        .variant(
+            "JS_DEFAULT_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_DEFAULT_CLAUSE,
+        )
+        .variant(
+            "JS_LABELED_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_LABELED_STATEMENT,
+        )
+        .variant(
+            "JS_THROW_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_THROW_STATEMENT,
+        )
+        .variant(
+            "JS_TRY_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_TRY_STATEMENT,
+        )
+        .variant(
+            "JS_TRY_FINALLY_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_TRY_FINALLY_STATEMENT,
+        )
+        .variant(
+            "JS_CATCH_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_CATCH_CLAUSE,
+        )
+        .variant(
+            "JS_CATCH_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::JS_CATCH_DECLARATION,
+        )
+        .variant(
+            "JS_FINALLY_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_FINALLY_CLAUSE,
+        )
+        .variant(
+            "JS_DEBUGGER_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_DEBUGGER_STATEMENT,
+        )
+        .variant(
+            "JS_FUNCTION_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::JS_FUNCTION_DECLARATION,
+        )
+        .variant("JS_PARAMETERS", rome_js_syntax::JsSyntaxKind::JS_PARAMETERS)
+        .variant(
+            "JS_PARAMETER_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_PARAMETER_LIST,
+        )
+        .variant(
+            "JS_FORMAL_PARAMETER",
+            rome_js_syntax::JsSyntaxKind::JS_FORMAL_PARAMETER,
+        )
+        .variant(
+            "JS_REST_PARAMETER",
+            rome_js_syntax::JsSyntaxKind::JS_REST_PARAMETER,
+        )
+        .variant(
+            "TS_THIS_PARAMETER",
+            rome_js_syntax::JsSyntaxKind::TS_THIS_PARAMETER,
+        )
+        .variant(
+            "TS_PROPERTY_PARAMETER",
+            rome_js_syntax::JsSyntaxKind::TS_PROPERTY_PARAMETER,
+        )
+        .variant(
+            "TS_PROPERTY_PARAMETER_MODIFIER_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_PROPERTY_PARAMETER_MODIFIER_LIST,
+        )
+        .variant(
+            "TS_TYPE_ANNOTATION",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_ANNOTATION,
+        )
+        .variant(
+            "TS_RETURN_TYPE_ANNOTATION",
+            rome_js_syntax::JsSyntaxKind::TS_RETURN_TYPE_ANNOTATION,
+        )
+        .variant(
+            "JS_IDENTIFIER_BINDING",
+            rome_js_syntax::JsSyntaxKind::JS_IDENTIFIER_BINDING,
+        )
+        .variant(
+            "JS_IDENTIFIER_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_IDENTIFIER_EXPRESSION,
+        )
+        .variant(
+            "JS_REFERENCE_IDENTIFIER",
+            rome_js_syntax::JsSyntaxKind::JS_REFERENCE_IDENTIFIER,
+        )
+        .variant("JS_NAME", rome_js_syntax::JsSyntaxKind::JS_NAME)
+        .variant(
+            "JS_PRIVATE_NAME",
+            rome_js_syntax::JsSyntaxKind::JS_PRIVATE_NAME,
+        )
+        .variant(
+            "JS_THIS_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_THIS_EXPRESSION,
+        )
+        .variant(
+            "JS_ARRAY_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_ARRAY_EXPRESSION,
+        )
+        .variant(
+            "JS_ARRAY_ELEMENT_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_ARRAY_ELEMENT_LIST,
+        )
+        .variant("JS_ARRAY_HOLE", rome_js_syntax::JsSyntaxKind::JS_ARRAY_HOLE)
+        .variant(
+            "JS_COMPUTED_MEMBER_NAME",
+            rome_js_syntax::JsSyntaxKind::JS_COMPUTED_MEMBER_NAME,
+        )
+        .variant(
+            "JS_LITERAL_MEMBER_NAME",
+            rome_js_syntax::JsSyntaxKind::JS_LITERAL_MEMBER_NAME,
+        )
+        .variant(
+            "JS_OBJECT_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_OBJECT_EXPRESSION,
+        )
+        .variant(
+            "JS_OBJECT_MEMBER_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_OBJECT_MEMBER_LIST,
+        )
+        .variant(
+            "JS_PROPERTY_OBJECT_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_PROPERTY_OBJECT_MEMBER,
+        )
+        .variant(
+            "JS_GETTER_OBJECT_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_GETTER_OBJECT_MEMBER,
+        )
+        .variant(
+            "JS_SETTER_OBJECT_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_SETTER_OBJECT_MEMBER,
+        )
+        .variant(
+            "JS_METHOD_OBJECT_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_METHOD_OBJECT_MEMBER,
+        )
+        .variant(
+            "JS_SUPER_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_SUPER_EXPRESSION,
+        )
+        .variant(
+            "JS_PARENTHESIZED_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_PARENTHESIZED_EXPRESSION,
+        )
+        .variant(
+            "JS_NEW_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_NEW_EXPRESSION,
+        )
+        .variant(
+            "JS_FUNCTION_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_FUNCTION_EXPRESSION,
+        )
+        .variant(
+            "JS_STATIC_MEMBER_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_STATIC_MEMBER_EXPRESSION,
+        )
+        .variant(
+            "JS_COMPUTED_MEMBER_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_COMPUTED_MEMBER_EXPRESSION,
+        )
+        .variant(
+            "JS_CALL_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_CALL_EXPRESSION,
+        )
+        .variant(
+            "JS_UNARY_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_UNARY_EXPRESSION,
+        )
+        .variant(
+            "JS_PRE_UPDATE_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_PRE_UPDATE_EXPRESSION,
+        )
+        .variant(
+            "JS_POST_UPDATE_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_POST_UPDATE_EXPRESSION,
+        )
+        .variant(
+            "JS_BINARY_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_BINARY_EXPRESSION,
+        )
+        .variant(
+            "JS_INSTANCEOF_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_INSTANCEOF_EXPRESSION,
+        )
+        .variant(
+            "JS_IN_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_IN_EXPRESSION,
+        )
+        .variant(
+            "JS_LOGICAL_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_LOGICAL_EXPRESSION,
+        )
+        .variant(
+            "JS_CONDITIONAL_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_CONDITIONAL_EXPRESSION,
+        )
+        .variant(
+            "JS_ASSIGNMENT_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_ASSIGNMENT_EXPRESSION,
+        )
+        .variant(
+            "JS_SEQUENCE_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_SEQUENCE_EXPRESSION,
+        )
+        .variant(
+            "JS_CALL_ARGUMENTS",
+            rome_js_syntax::JsSyntaxKind::JS_CALL_ARGUMENTS,
+        )
+        .variant(
+            "JS_CALL_ARGUMENT_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_CALL_ARGUMENT_LIST,
+        )
+        .variant(
+            "JS_STRING_LITERAL_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_STRING_LITERAL_EXPRESSION,
+        )
+        .variant(
+            "JS_NUMBER_LITERAL_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_NUMBER_LITERAL_EXPRESSION,
+        )
+        .variant(
+            "JS_BIGINT_LITERAL_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_BIGINT_LITERAL_EXPRESSION,
+        )
+        .variant(
+            "JS_BOOLEAN_LITERAL_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_BOOLEAN_LITERAL_EXPRESSION,
+        )
+        .variant(
+            "JS_NULL_LITERAL_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_NULL_LITERAL_EXPRESSION,
+        )
+        .variant(
+            "JS_REGEX_LITERAL_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_REGEX_LITERAL_EXPRESSION,
+        )
+        .variant(
+            "JS_TEMPLATE_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_TEMPLATE_EXPRESSION,
+        )
+        .variant(
+            "JS_TEMPLATE_ELEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_TEMPLATE_ELEMENT,
+        )
+        .variant(
+            "JS_TEMPLATE_CHUNK_ELEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_TEMPLATE_CHUNK_ELEMENT,
+        )
+        .variant(
+            "JS_TEMPLATE_ELEMENT_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_TEMPLATE_ELEMENT_LIST,
+        )
+        .variant(
+            "JS_IMPORT_CALL_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_IMPORT_CALL_EXPRESSION,
+        )
+        .variant(
+            "JS_NEW_TARGET_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_NEW_TARGET_EXPRESSION,
+        )
+        .variant(
+            "JS_IMPORT_META_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_IMPORT_META_EXPRESSION,
+        )
+        .variant(
+            "JS_SHORTHAND_PROPERTY_OBJECT_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_SHORTHAND_PROPERTY_OBJECT_MEMBER,
+        )
+        .variant("JS_SPREAD", rome_js_syntax::JsSyntaxKind::JS_SPREAD)
+        .variant(
+            "JS_OBJECT_BINDING_PATTERN",
+            rome_js_syntax::JsSyntaxKind::JS_OBJECT_BINDING_PATTERN,
+        )
+        .variant(
+            "JS_ARRAY_BINDING_PATTERN",
+            rome_js_syntax::JsSyntaxKind::JS_ARRAY_BINDING_PATTERN,
+        )
+        .variant(
+            "JS_ARRAY_BINDING_PATTERN_ELEMENT_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_ARRAY_BINDING_PATTERN_ELEMENT_LIST,
+        )
+        .variant(
+            "JS_BINDING_PATTERN_WITH_DEFAULT",
+            rome_js_syntax::JsSyntaxKind::JS_BINDING_PATTERN_WITH_DEFAULT,
+        )
+        .variant(
+            "JS_ARRAY_BINDING_PATTERN_REST_ELEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_ARRAY_BINDING_PATTERN_REST_ELEMENT,
+        )
+        .variant(
+            "JS_OBJECT_BINDING_PATTERN_PROPERTY_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_OBJECT_BINDING_PATTERN_PROPERTY_LIST,
+        )
+        .variant(
+            "JS_OBJECT_BINDING_PATTERN_REST",
+            rome_js_syntax::JsSyntaxKind::JS_OBJECT_BINDING_PATTERN_REST,
+        )
+        .variant(
+            "JS_OBJECT_BINDING_PATTERN_PROPERTY",
+            rome_js_syntax::JsSyntaxKind::JS_OBJECT_BINDING_PATTERN_PROPERTY,
+        )
+        .variant(
+            "JS_OBJECT_BINDING_PATTERN_SHORTHAND_PROPERTY",
+            rome_js_syntax::JsSyntaxKind::JS_OBJECT_BINDING_PATTERN_SHORTHAND_PROPERTY,
+        )
+        .variant(
+            "JS_ARROW_FUNCTION_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_ARROW_FUNCTION_EXPRESSION,
+        )
+        .variant(
+            "JS_YIELD_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_YIELD_EXPRESSION,
+        )
+        .variant(
+            "JS_YIELD_ARGUMENT",
+            rome_js_syntax::JsSyntaxKind::JS_YIELD_ARGUMENT,
+        )
+        .variant(
+            "JS_CLASS_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::JS_CLASS_DECLARATION,
+        )
+        .variant(
+            "JS_CLASS_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_CLASS_EXPRESSION,
+        )
+        .variant(
+            "JS_CLASS_MEMBER_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_CLASS_MEMBER_LIST,
+        )
+        .variant(
+            "JS_STATIC_MODIFIER",
+            rome_js_syntax::JsSyntaxKind::JS_STATIC_MODIFIER,
+        )
+        .variant(
+            "JS_ACCESSOR_MODIFIER",
+            rome_js_syntax::JsSyntaxKind::JS_ACCESSOR_MODIFIER,
+        )
+        .variant(
+            "TS_DECLARE_MODIFIER",
+            rome_js_syntax::JsSyntaxKind::TS_DECLARE_MODIFIER,
+        )
+        .variant(
+            "TS_READONLY_MODIFIER",
+            rome_js_syntax::JsSyntaxKind::TS_READONLY_MODIFIER,
+        )
+        .variant(
+            "TS_ABSTRACT_MODIFIER",
+            rome_js_syntax::JsSyntaxKind::TS_ABSTRACT_MODIFIER,
+        )
+        .variant(
+            "TS_OVERRIDE_MODIFIER",
+            rome_js_syntax::JsSyntaxKind::TS_OVERRIDE_MODIFIER,
+        )
+        .variant(
+            "TS_ACCESSIBILITY_MODIFIER",
+            rome_js_syntax::JsSyntaxKind::TS_ACCESSIBILITY_MODIFIER,
+        )
+        .variant(
+            "TS_CONST_MODIFIER",
+            rome_js_syntax::JsSyntaxKind::TS_CONST_MODIFIER,
+        )
+        .variant(
+            "TS_IN_MODIFIER",
+            rome_js_syntax::JsSyntaxKind::TS_IN_MODIFIER,
+        )
+        .variant(
+            "TS_OUT_MODIFIER",
+            rome_js_syntax::JsSyntaxKind::TS_OUT_MODIFIER,
+        )
+        .variant(
+            "JS_EXTENDS_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_EXTENDS_CLAUSE,
+        )
+        .variant(
+            "TS_IMPLEMENTS_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::TS_IMPLEMENTS_CLAUSE,
+        )
+        .variant(
+            "JS_PRIVATE_CLASS_MEMBER_NAME",
+            rome_js_syntax::JsSyntaxKind::JS_PRIVATE_CLASS_MEMBER_NAME,
+        )
+        .variant(
+            "JS_CONSTRUCTOR_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_CONSTRUCTOR_CLASS_MEMBER,
+        )
+        .variant(
+            "TS_CONSTRUCTOR_SIGNATURE_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_CONSTRUCTOR_SIGNATURE_CLASS_MEMBER,
+        )
+        .variant(
+            "JS_CONSTRUCTOR_MODIFIER_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_CONSTRUCTOR_MODIFIER_LIST,
+        )
+        .variant(
+            "JS_CONSTRUCTOR_PARAMETER_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_CONSTRUCTOR_PARAMETER_LIST,
+        )
+        .variant(
+            "JS_CONSTRUCTOR_PARAMETERS",
+            rome_js_syntax::JsSyntaxKind::JS_CONSTRUCTOR_PARAMETERS,
+        )
+        .variant(
+            "JS_PROPERTY_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_PROPERTY_CLASS_MEMBER,
+        )
+        .variant(
+            "JS_PROPERTY_MODIFIER_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_PROPERTY_MODIFIER_LIST,
+        )
+        .variant(
+            "TS_OPTIONAL_PROPERTY_ANNOTATION",
+            rome_js_syntax::JsSyntaxKind::TS_OPTIONAL_PROPERTY_ANNOTATION,
+        )
+        .variant(
+            "TS_DEFINITE_PROPERTY_ANNOTATION",
+            rome_js_syntax::JsSyntaxKind::TS_DEFINITE_PROPERTY_ANNOTATION,
+        )
+        .variant(
+            "JS_STATIC_INITIALIZATION_BLOCK_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_STATIC_INITIALIZATION_BLOCK_CLASS_MEMBER,
+        )
+        .variant(
+            "JS_METHOD_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_METHOD_CLASS_MEMBER,
+        )
+        .variant(
+            "JS_METHOD_MODIFIER_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_METHOD_MODIFIER_LIST,
+        )
+        .variant(
+            "JS_GETTER_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_GETTER_CLASS_MEMBER,
+        )
+        .variant(
+            "JS_SETTER_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_SETTER_CLASS_MEMBER,
+        )
+        .variant(
+            "JS_EMPTY_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_EMPTY_CLASS_MEMBER,
+        )
+        .variant(
+            "JS_ASSIGNMENT_WITH_DEFAULT",
+            rome_js_syntax::JsSyntaxKind::JS_ASSIGNMENT_WITH_DEFAULT,
+        )
+        .variant(
+            "JS_PARENTHESIZED_ASSIGNMENT",
+            rome_js_syntax::JsSyntaxKind::JS_PARENTHESIZED_ASSIGNMENT,
+        )
+        .variant(
+            "JS_IDENTIFIER_ASSIGNMENT",
+            rome_js_syntax::JsSyntaxKind::JS_IDENTIFIER_ASSIGNMENT,
+        )
+        .variant(
+            "JS_STATIC_MEMBER_ASSIGNMENT",
+            rome_js_syntax::JsSyntaxKind::JS_STATIC_MEMBER_ASSIGNMENT,
+        )
+        .variant(
+            "JS_COMPUTED_MEMBER_ASSIGNMENT",
+            rome_js_syntax::JsSyntaxKind::JS_COMPUTED_MEMBER_ASSIGNMENT,
+        )
+        .variant(
+            "TS_NON_NULL_ASSERTION_ASSIGNMENT",
+            rome_js_syntax::JsSyntaxKind::TS_NON_NULL_ASSERTION_ASSIGNMENT,
+        )
+        .variant(
+            "TS_AS_ASSIGNMENT",
+            rome_js_syntax::JsSyntaxKind::TS_AS_ASSIGNMENT,
+        )
+        .variant(
+            "TS_SATISFIES_ASSIGNMENT",
+            rome_js_syntax::JsSyntaxKind::TS_SATISFIES_ASSIGNMENT,
+        )
+        .variant(
+            "TS_TYPE_ASSERTION_ASSIGNMENT",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_ASSERTION_ASSIGNMENT,
+        )
+        .variant(
+            "JS_ARRAY_ASSIGNMENT_PATTERN",
+            rome_js_syntax::JsSyntaxKind::JS_ARRAY_ASSIGNMENT_PATTERN,
+        )
+        .variant(
+            "JS_ARRAY_ASSIGNMENT_PATTERN_ELEMENT_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_ARRAY_ASSIGNMENT_PATTERN_ELEMENT_LIST,
+        )
+        .variant(
+            "JS_ARRAY_ASSIGNMENT_PATTERN_REST_ELEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_ARRAY_ASSIGNMENT_PATTERN_REST_ELEMENT,
+        )
+        .variant(
+            "JS_OBJECT_ASSIGNMENT_PATTERN",
+            rome_js_syntax::JsSyntaxKind::JS_OBJECT_ASSIGNMENT_PATTERN,
+        )
+        .variant(
+            "JS_OBJECT_ASSIGNMENT_PATTERN_PROPERTY_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_OBJECT_ASSIGNMENT_PATTERN_PROPERTY_LIST,
+        )
+        .variant(
+            "JS_OBJECT_ASSIGNMENT_PATTERN_SHORTHAND_PROPERTY",
+            rome_js_syntax::JsSyntaxKind::JS_OBJECT_ASSIGNMENT_PATTERN_SHORTHAND_PROPERTY,
+        )
+        .variant(
+            "JS_OBJECT_ASSIGNMENT_PATTERN_PROPERTY",
+            rome_js_syntax::JsSyntaxKind::JS_OBJECT_ASSIGNMENT_PATTERN_PROPERTY,
+        )
+        .variant(
+            "JS_OBJECT_ASSIGNMENT_PATTERN_REST",
+            rome_js_syntax::JsSyntaxKind::JS_OBJECT_ASSIGNMENT_PATTERN_REST,
+        )
+        .variant("JS_IMPORT", rome_js_syntax::JsSyntaxKind::JS_IMPORT)
+        .variant(
+            "JS_IMPORT_BARE_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_IMPORT_BARE_CLAUSE,
+        )
+        .variant(
+            "JS_IMPORT_DEFAULT_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_IMPORT_DEFAULT_CLAUSE,
+        )
+        .variant(
+            "JS_IMPORT_NAMESPACE_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_IMPORT_NAMESPACE_CLAUSE,
+        )
+        .variant(
+            "JS_IMPORT_NAMED_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_IMPORT_NAMED_CLAUSE,
+        )
+        .variant(
+            "JS_NAMED_IMPORT_SPECIFIERS",
+            rome_js_syntax::JsSyntaxKind::JS_NAMED_IMPORT_SPECIFIERS,
+        )
+        .variant(
+            "JS_NAMED_IMPORT_SPECIFIER_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_NAMED_IMPORT_SPECIFIER_LIST,
+        )
+        .variant(
+            "JS_NAMESPACE_IMPORT_SPECIFIER",
+            rome_js_syntax::JsSyntaxKind::JS_NAMESPACE_IMPORT_SPECIFIER,
+        )
+        .variant(
+            "JS_DEFAULT_IMPORT_SPECIFIER",
+            rome_js_syntax::JsSyntaxKind::JS_DEFAULT_IMPORT_SPECIFIER,
+        )
+        .variant(
+            "JS_NAMED_IMPORT_SPECIFIER",
+            rome_js_syntax::JsSyntaxKind::JS_NAMED_IMPORT_SPECIFIER,
+        )
+        .variant(
+            "JS_SHORTHAND_NAMED_IMPORT_SPECIFIER",
+            rome_js_syntax::JsSyntaxKind::JS_SHORTHAND_NAMED_IMPORT_SPECIFIER,
+        )
+        .variant(
+            "JS_IMPORT_ASSERTION",
+            rome_js_syntax::JsSyntaxKind::JS_IMPORT_ASSERTION,
+        )
+        .variant(
+            "JS_IMPORT_ASSERTION_ENTRY_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_IMPORT_ASSERTION_ENTRY_LIST,
+        )
+        .variant(
+            "JS_IMPORT_ASSERTION_ENTRY",
+            rome_js_syntax::JsSyntaxKind::JS_IMPORT_ASSERTION_ENTRY,
+        )
+        .variant(
+            "JS_MODULE_SOURCE",
+            rome_js_syntax::JsSyntaxKind::JS_MODULE_SOURCE,
+        )
+        .variant("JS_EXPORT", rome_js_syntax::JsSyntaxKind::JS_EXPORT)
+        .variant(
+            "JS_EXPORT_NAMED_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_EXPORT_NAMED_CLAUSE,
+        )
+        .variant(
+            "JS_EXPORT_NAMED_SPECIFIER_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_EXPORT_NAMED_SPECIFIER_LIST,
+        )
+        .variant(
+            "JS_EXPORT_NAMED_SHORTHAND_SPECIFIER",
+            rome_js_syntax::JsSyntaxKind::JS_EXPORT_NAMED_SHORTHAND_SPECIFIER,
+        )
+        .variant(
+            "JS_EXPORT_NAMED_SPECIFIER",
+            rome_js_syntax::JsSyntaxKind::JS_EXPORT_NAMED_SPECIFIER,
+        )
+        .variant(
+            "JS_EXPORT_DEFAULT_EXPRESSION_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_EXPORT_DEFAULT_EXPRESSION_CLAUSE,
+        )
+        .variant(
+            "JS_EXPORT_DEFAULT_DECLARATION_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_EXPORT_DEFAULT_DECLARATION_CLAUSE,
+        )
+        .variant(
+            "JS_CLASS_EXPORT_DEFAULT_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::JS_CLASS_EXPORT_DEFAULT_DECLARATION,
+        )
+        .variant(
+            "JS_FUNCTION_EXPORT_DEFAULT_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::JS_FUNCTION_EXPORT_DEFAULT_DECLARATION,
+        )
+        .variant(
+            "JS_EXPORT_FROM_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_EXPORT_FROM_CLAUSE,
+        )
+        .variant(
+            "JS_EXPORT_NAMED_FROM_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_EXPORT_NAMED_FROM_CLAUSE,
+        )
+        .variant(
+            "JS_EXPORT_NAMED_FROM_SPECIFIER_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_EXPORT_NAMED_FROM_SPECIFIER_LIST,
+        )
+        .variant(
+            "JS_EXPORT_NAMED_FROM_SPECIFIER",
+            rome_js_syntax::JsSyntaxKind::JS_EXPORT_NAMED_FROM_SPECIFIER,
+        )
+        .variant(
+            "JS_EXPORT_AS_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JS_EXPORT_AS_CLAUSE,
+        )
+        .variant(
+            "TS_EXPORT_AS_NAMESPACE_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::TS_EXPORT_AS_NAMESPACE_CLAUSE,
+        )
+        .variant(
+            "TS_EXPORT_ASSIGNMENT_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::TS_EXPORT_ASSIGNMENT_CLAUSE,
+        )
+        .variant(
+            "TS_EXPORT_DECLARE_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::TS_EXPORT_DECLARE_CLAUSE,
+        )
+        .variant(
+            "JS_LITERAL_EXPORT_NAME",
+            rome_js_syntax::JsSyntaxKind::JS_LITERAL_EXPORT_NAME,
+        )
+        .variant(
+            "JS_AWAIT_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_AWAIT_EXPRESSION,
+        )
+        .variant("JS_DECORATOR", rome_js_syntax::JsSyntaxKind::JS_DECORATOR)
+        .variant(
+            "JS_DECORATOR_LIST",
+            rome_js_syntax::JsSyntaxKind::JS_DECORATOR_LIST,
+        )
+        .variant(
+            "TS_IDENTIFIER_BINDING",
+            rome_js_syntax::JsSyntaxKind::TS_IDENTIFIER_BINDING,
+        )
+        .variant("TS_ANY_TYPE", rome_js_syntax::JsSyntaxKind::TS_ANY_TYPE)
+        .variant(
+            "TS_UNKNOWN_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_UNKNOWN_TYPE,
+        )
+        .variant(
+            "TS_NUMBER_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_NUMBER_TYPE,
+        )
+        .variant(
+            "TS_NON_PRIMITIVE_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_NON_PRIMITIVE_TYPE,
+        )
+        .variant(
+            "TS_BOOLEAN_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_BOOLEAN_TYPE,
+        )
+        .variant(
+            "TS_BIGINT_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_BIGINT_TYPE,
+        )
+        .variant(
+            "TS_STRING_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_STRING_TYPE,
+        )
+        .variant(
+            "TS_SYMBOL_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_SYMBOL_TYPE,
+        )
+        .variant("TS_VOID_TYPE", rome_js_syntax::JsSyntaxKind::TS_VOID_TYPE)
+        .variant(
+            "TS_UNDEFINED_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_UNDEFINED_TYPE,
+        )
+        .variant("TS_NEVER_TYPE", rome_js_syntax::JsSyntaxKind::TS_NEVER_TYPE)
+        .variant("TS_THIS_TYPE", rome_js_syntax::JsSyntaxKind::TS_THIS_TYPE)
+        .variant(
+            "TS_TYPEOF_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_TYPEOF_TYPE,
+        )
+        .variant(
+            "TS_PARENTHESIZED_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_PARENTHESIZED_TYPE,
+        )
+        .variant(
+            "TS_MAPPED_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_MAPPED_TYPE,
+        )
+        .variant(
+            "TS_MAPPED_TYPE_OPTIONAL_MODIFIER_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::TS_MAPPED_TYPE_OPTIONAL_MODIFIER_CLAUSE,
+        )
+        .variant(
+            "TS_MAPPED_TYPE_READONLY_MODIFIER_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::TS_MAPPED_TYPE_READONLY_MODIFIER_CLAUSE,
+        )
+        .variant(
+            "TS_MAPPED_TYPE_AS_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::TS_MAPPED_TYPE_AS_CLAUSE,
+        )
+        .variant(
+            "TS_TYPE_ALIAS_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_ALIAS_DECLARATION,
+        )
+        .variant(
+            "TS_MODULE_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::TS_MODULE_DECLARATION,
+        )
+        .variant(
+            "TS_GLOBAL_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::TS_GLOBAL_DECLARATION,
+        )
+        .variant(
+            "TS_QUALIFIED_MODULE_NAME",
+            rome_js_syntax::JsSyntaxKind::TS_QUALIFIED_MODULE_NAME,
+        )
+        .variant(
+            "TS_MODULE_BLOCK",
+            rome_js_syntax::JsSyntaxKind::TS_MODULE_BLOCK,
+        )
+        .variant(
+            "TS_EXTERNAL_MODULE_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::TS_EXTERNAL_MODULE_DECLARATION,
+        )
+        .variant(
+            "TS_EMPTY_EXTERNAL_MODULE_DECLARATION_BODY",
+            rome_js_syntax::JsSyntaxKind::TS_EMPTY_EXTERNAL_MODULE_DECLARATION_BODY,
+        )
+        .variant(
+            "TS_QUALIFIED_NAME",
+            rome_js_syntax::JsSyntaxKind::TS_QUALIFIED_NAME,
+        )
+        .variant(
+            "TS_REFERENCE_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_REFERENCE_TYPE,
+        )
+        .variant("TS_UNION_TYPE", rome_js_syntax::JsSyntaxKind::TS_UNION_TYPE)
+        .variant(
+            "TS_UNION_TYPE_VARIANT_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_UNION_TYPE_VARIANT_LIST,
+        )
+        .variant(
+            "TS_INTERSECTION_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_INTERSECTION_TYPE,
+        )
+        .variant(
+            "TS_INTERSECTION_TYPE_ELEMENT_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_INTERSECTION_TYPE_ELEMENT_LIST,
+        )
+        .variant(
+            "TS_OBJECT_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_OBJECT_TYPE,
+        )
+        .variant(
+            "TS_TYPE_MEMBER_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_MEMBER_LIST,
+        )
+        .variant(
+            "TS_INTERFACE_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::TS_INTERFACE_DECLARATION,
+        )
+        .variant(
+            "TS_EXTENDS_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::TS_EXTENDS_CLAUSE,
+        )
+        .variant(
+            "TS_PROPERTY_SIGNATURE_TYPE_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_PROPERTY_SIGNATURE_TYPE_MEMBER,
+        )
+        .variant(
+            "TS_METHOD_SIGNATURE_TYPE_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_METHOD_SIGNATURE_TYPE_MEMBER,
+        )
+        .variant(
+            "TS_CALL_SIGNATURE_TYPE_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_CALL_SIGNATURE_TYPE_MEMBER,
+        )
+        .variant(
+            "TS_CONSTRUCT_SIGNATURE_TYPE_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_CONSTRUCT_SIGNATURE_TYPE_MEMBER,
+        )
+        .variant(
+            "TS_GETTER_SIGNATURE_TYPE_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_GETTER_SIGNATURE_TYPE_MEMBER,
+        )
+        .variant(
+            "TS_SETTER_SIGNATURE_TYPE_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_SETTER_SIGNATURE_TYPE_MEMBER,
+        )
+        .variant(
+            "TS_INDEX_SIGNATURE_TYPE_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_INDEX_SIGNATURE_TYPE_MEMBER,
+        )
+        .variant(
+            "TS_IMPORT_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_IMPORT_TYPE,
+        )
+        .variant(
+            "TS_IMPORT_TYPE_QUALIFIER",
+            rome_js_syntax::JsSyntaxKind::TS_IMPORT_TYPE_QUALIFIER,
+        )
+        .variant("TS_ARRAY_TYPE", rome_js_syntax::JsSyntaxKind::TS_ARRAY_TYPE)
+        .variant(
+            "TS_INDEXED_ACCESS_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_INDEXED_ACCESS_TYPE,
+        )
+        .variant("TS_TUPLE_TYPE", rome_js_syntax::JsSyntaxKind::TS_TUPLE_TYPE)
+        .variant(
+            "TS_TUPLE_TYPE_ELEMENT_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_TUPLE_TYPE_ELEMENT_LIST,
+        )
+        .variant(
+            "TS_REST_TUPLE_TYPE_ELEMENT",
+            rome_js_syntax::JsSyntaxKind::TS_REST_TUPLE_TYPE_ELEMENT,
+        )
+        .variant(
+            "TS_OPTIONAL_TUPLE_TYPE_ELEMENT",
+            rome_js_syntax::JsSyntaxKind::TS_OPTIONAL_TUPLE_TYPE_ELEMENT,
+        )
+        .variant(
+            "TS_NAMED_TUPLE_TYPE_ELEMENT",
+            rome_js_syntax::JsSyntaxKind::TS_NAMED_TUPLE_TYPE_ELEMENT,
+        )
+        .variant(
+            "TS_TYPE_OPERATOR_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_OPERATOR_TYPE,
+        )
+        .variant("TS_INFER_TYPE", rome_js_syntax::JsSyntaxKind::TS_INFER_TYPE)
+        .variant(
+            "TS_CONSTRUCTOR_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_CONSTRUCTOR_TYPE,
+        )
+        .variant(
+            "TS_FUNCTION_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_FUNCTION_TYPE,
+        )
+        .variant(
+            "TS_PREDICATE_RETURN_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_PREDICATE_RETURN_TYPE,
+        )
+        .variant(
+            "TS_ASSERTS_RETURN_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_ASSERTS_RETURN_TYPE,
+        )
+        .variant(
+            "TS_ASSERTS_CONDITION",
+            rome_js_syntax::JsSyntaxKind::TS_ASSERTS_CONDITION,
+        )
+        .variant(
+            "TS_TYPE_PARAMETERS",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_PARAMETERS,
+        )
+        .variant(
+            "TS_TYPE_PARAMETER_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_PARAMETER_LIST,
+        )
+        .variant(
+            "TS_TYPE_PARAMETER",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_PARAMETER,
+        )
+        .variant(
+            "TS_TYPE_PARAMETER_MODIFIER_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_PARAMETER_MODIFIER_LIST,
+        )
+        .variant(
+            "TS_TYPE_PARAMETER_NAME",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_PARAMETER_NAME,
+        )
+        .variant(
+            "TS_TYPE_CONSTRAINT_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_CONSTRAINT_CLAUSE,
+        )
+        .variant(
+            "TS_DEFAULT_TYPE_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::TS_DEFAULT_TYPE_CLAUSE,
+        )
+        .variant(
+            "TS_STRING_LITERAL_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_STRING_LITERAL_TYPE,
+        )
+        .variant(
+            "TS_NUMBER_LITERAL_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_NUMBER_LITERAL_TYPE,
+        )
+        .variant(
+            "TS_BIGINT_LITERAL_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_BIGINT_LITERAL_TYPE,
+        )
+        .variant(
+            "TS_BOOLEAN_LITERAL_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_BOOLEAN_LITERAL_TYPE,
+        )
+        .variant(
+            "TS_NULL_LITERAL_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_NULL_LITERAL_TYPE,
+        )
+        .variant(
+            "TS_TEMPLATE_LITERAL_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_TEMPLATE_LITERAL_TYPE,
+        )
+        .variant(
+            "TS_TEMPLATE_ELEMENT_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_TEMPLATE_ELEMENT_LIST,
+        )
+        .variant(
+            "TS_TEMPLATE_CHUNK_ELEMENT",
+            rome_js_syntax::JsSyntaxKind::TS_TEMPLATE_CHUNK_ELEMENT,
+        )
+        .variant(
+            "TS_TEMPLATE_ELEMENT",
+            rome_js_syntax::JsSyntaxKind::TS_TEMPLATE_ELEMENT,
+        )
+        .variant(
+            "TS_TYPE_ARGUMENTS",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_ARGUMENTS,
+        )
+        .variant(
+            "TS_TYPE_ARGUMENT_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_ARGUMENT_LIST,
+        )
+        .variant("TS_TYPE_LIST", rome_js_syntax::JsSyntaxKind::TS_TYPE_LIST)
+        .variant("TS_EXTENDS", rome_js_syntax::JsSyntaxKind::TS_EXTENDS)
+        .variant(
+            "TS_CONDITIONAL_TYPE",
+            rome_js_syntax::JsSyntaxKind::TS_CONDITIONAL_TYPE,
+        )
+        .variant(
+            "TS_NON_NULL_ASSERTION_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::TS_NON_NULL_ASSERTION_EXPRESSION,
+        )
+        .variant(
+            "TS_TYPE_ASSERTION_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::TS_TYPE_ASSERTION_EXPRESSION,
+        )
+        .variant(
+            "TS_AS_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::TS_AS_EXPRESSION,
+        )
+        .variant(
+            "TS_SATISFIES_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::TS_SATISFIES_EXPRESSION,
+        )
+        .variant(
+            "TS_INSTANTIATION_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::TS_INSTANTIATION_EXPRESSION,
+        )
+        .variant(
+            "TS_ENUM_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::TS_ENUM_DECLARATION,
+        )
+        .variant(
+            "TS_ENUM_MEMBER_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_ENUM_MEMBER_LIST,
+        )
+        .variant(
+            "TS_ENUM_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_ENUM_MEMBER,
+        )
+        .variant(
+            "TS_IMPORT_EQUALS_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::TS_IMPORT_EQUALS_DECLARATION,
+        )
+        .variant(
+            "TS_EXTERNAL_MODULE_REFERENCE",
+            rome_js_syntax::JsSyntaxKind::TS_EXTERNAL_MODULE_REFERENCE,
+        )
+        .variant(
+            "TS_NAME_WITH_TYPE_ARGUMENTS",
+            rome_js_syntax::JsSyntaxKind::TS_NAME_WITH_TYPE_ARGUMENTS,
+        )
+        .variant(
+            "TS_DECLARE_FUNCTION_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::TS_DECLARE_FUNCTION_DECLARATION,
+        )
+        .variant(
+            "TS_DECLARE_FUNCTION_EXPORT_DEFAULT_DECLARATION",
+            rome_js_syntax::JsSyntaxKind::TS_DECLARE_FUNCTION_EXPORT_DEFAULT_DECLARATION,
+        )
+        .variant(
+            "TS_DECLARE_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::TS_DECLARE_STATEMENT,
+        )
+        .variant(
+            "TS_INDEX_SIGNATURE_PARAMETER",
+            rome_js_syntax::JsSyntaxKind::TS_INDEX_SIGNATURE_PARAMETER,
+        )
+        .variant(
+            "TS_PROPERTY_SIGNATURE_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_PROPERTY_SIGNATURE_CLASS_MEMBER,
+        )
+        .variant(
+            "TS_INITIALIZED_PROPERTY_SIGNATURE_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_INITIALIZED_PROPERTY_SIGNATURE_CLASS_MEMBER,
+        )
+        .variant(
+            "TS_PROPERTY_SIGNATURE_MODIFIER_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_PROPERTY_SIGNATURE_MODIFIER_LIST,
+        )
+        .variant(
+            "TS_METHOD_SIGNATURE_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_METHOD_SIGNATURE_CLASS_MEMBER,
+        )
+        .variant(
+            "TS_METHOD_SIGNATURE_MODIFIER_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_METHOD_SIGNATURE_MODIFIER_LIST,
+        )
+        .variant(
+            "TS_GETTER_SIGNATURE_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_GETTER_SIGNATURE_CLASS_MEMBER,
+        )
+        .variant(
+            "TS_SETTER_SIGNATURE_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_SETTER_SIGNATURE_CLASS_MEMBER,
+        )
+        .variant(
+            "TS_INDEX_SIGNATURE_CLASS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::TS_INDEX_SIGNATURE_CLASS_MEMBER,
+        )
+        .variant(
+            "TS_INDEX_SIGNATURE_MODIFIER_LIST",
+            rome_js_syntax::JsSyntaxKind::TS_INDEX_SIGNATURE_MODIFIER_LIST,
+        )
+        .variant("JSX_NAME", rome_js_syntax::JsSyntaxKind::JSX_NAME)
+        .variant(
+            "JSX_NAMESPACE_NAME",
+            rome_js_syntax::JsSyntaxKind::JSX_NAMESPACE_NAME,
+        )
+        .variant(
+            "JSX_REFERENCE_IDENTIFIER",
+            rome_js_syntax::JsSyntaxKind::JSX_REFERENCE_IDENTIFIER,
+        )
+        .variant(
+            "JSX_TAG_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JSX_TAG_EXPRESSION,
+        )
+        .variant("JSX_ELEMENT", rome_js_syntax::JsSyntaxKind::JSX_ELEMENT)
+        .variant("JSX_FRAGMENT", rome_js_syntax::JsSyntaxKind::JSX_FRAGMENT)
+        .variant(
+            "JSX_OPENING_FRAGMENT",
+            rome_js_syntax::JsSyntaxKind::JSX_OPENING_FRAGMENT,
+        )
+        .variant(
+            "JSX_CLOSING_FRAGMENT",
+            rome_js_syntax::JsSyntaxKind::JSX_CLOSING_FRAGMENT,
+        )
+        .variant(
+            "JSX_SELF_CLOSING_ELEMENT",
+            rome_js_syntax::JsSyntaxKind::JSX_SELF_CLOSING_ELEMENT,
+        )
+        .variant(
+            "JSX_OPENING_ELEMENT",
+            rome_js_syntax::JsSyntaxKind::JSX_OPENING_ELEMENT,
+        )
+        .variant(
+            "JSX_CLOSING_ELEMENT",
+            rome_js_syntax::JsSyntaxKind::JSX_CLOSING_ELEMENT,
+        )
+        .variant(
+            "JSX_MEMBER_NAME",
+            rome_js_syntax::JsSyntaxKind::JSX_MEMBER_NAME,
+        )
+        .variant("JSX_TEXT", rome_js_syntax::JsSyntaxKind::JSX_TEXT)
+        .variant(
+            "JSX_ATTRIBUTE_LIST",
+            rome_js_syntax::JsSyntaxKind::JSX_ATTRIBUTE_LIST,
+        )
+        .variant("JSX_ATTRIBUTE", rome_js_syntax::JsSyntaxKind::JSX_ATTRIBUTE)
+        .variant(
+            "JSX_SPREAD_ATTRIBUTE",
+            rome_js_syntax::JsSyntaxKind::JSX_SPREAD_ATTRIBUTE,
+        )
+        .variant(
+            "JSX_ATTRIBUTE_INITIALIZER_CLAUSE",
+            rome_js_syntax::JsSyntaxKind::JSX_ATTRIBUTE_INITIALIZER_CLAUSE,
+        )
+        .variant(
+            "JSX_EXPRESSION_ATTRIBUTE_VALUE",
+            rome_js_syntax::JsSyntaxKind::JSX_EXPRESSION_ATTRIBUTE_VALUE,
+        )
+        .variant(
+            "JSX_CHILD_LIST",
+            rome_js_syntax::JsSyntaxKind::JSX_CHILD_LIST,
+        )
+        .variant(
+            "JSX_EXPRESSION_CHILD",
+            rome_js_syntax::JsSyntaxKind::JSX_EXPRESSION_CHILD,
+        )
+        .variant(
+            "JSX_SPREAD_CHILD",
+            rome_js_syntax::JsSyntaxKind::JSX_SPREAD_CHILD,
+        )
+        .variant("JSX_STRING", rome_js_syntax::JsSyntaxKind::JSX_STRING)
+        .variant("JS_BOGUS", rome_js_syntax::JsSyntaxKind::JS_BOGUS)
+        .variant(
+            "JS_BOGUS_EXPRESSION",
+            rome_js_syntax::JsSyntaxKind::JS_BOGUS_EXPRESSION,
+        )
+        .variant(
+            "JS_BOGUS_STATEMENT",
+            rome_js_syntax::JsSyntaxKind::JS_BOGUS_STATEMENT,
+        )
+        .variant(
+            "JS_BOGUS_MEMBER",
+            rome_js_syntax::JsSyntaxKind::JS_BOGUS_MEMBER,
+        )
+        .variant(
+            "JS_BOGUS_BINDING",
+            rome_js_syntax::JsSyntaxKind::JS_BOGUS_BINDING,
+        )
+        .variant(
+            "JS_BOGUS_PARAMETER",
+            rome_js_syntax::JsSyntaxKind::JS_BOGUS_PARAMETER,
+        )
+        .variant(
+            "JS_BOGUS_IMPORT_ASSERTION_ENTRY",
+            rome_js_syntax::JsSyntaxKind::JS_BOGUS_IMPORT_ASSERTION_ENTRY,
+        )
+        .variant(
+            "JS_BOGUS_NAMED_IMPORT_SPECIFIER",
+            rome_js_syntax::JsSyntaxKind::JS_BOGUS_NAMED_IMPORT_SPECIFIER,
+        )
+        .variant(
+            "JS_BOGUS_ASSIGNMENT",
+            rome_js_syntax::JsSyntaxKind::JS_BOGUS_ASSIGNMENT,
+        )
+        .variant("TS_BOGUS_TYPE", rome_js_syntax::JsSyntaxKind::TS_BOGUS_TYPE)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsAccessorModifier>(scope, global, "JsAccessorModifier")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifier_token", JsAccessorModifier_modifier_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsArrayAssignmentPattern>(
+            scope,
+            global,
+            "JsArrayAssignmentPattern",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "l_brack_token",
+            JsArrayAssignmentPattern_l_brack_token,
+        )
+        .method(scope, "elements", JsArrayAssignmentPattern_elements)
+        .method(
+            scope,
+            "r_brack_token",
+            JsArrayAssignmentPattern_r_brack_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsArrayAssignmentPatternRestElement>(
+            scope,
+            global,
+            "JsArrayAssignmentPatternRestElement",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "dotdotdot_token",
+            JsArrayAssignmentPatternRestElement_dotdotdot_token,
+        )
+        .method(
+            scope,
+            "pattern",
+            JsArrayAssignmentPatternRestElement_pattern,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsArrayBindingPattern>(
+            scope,
+            global,
+            "JsArrayBindingPattern",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_brack_token", JsArrayBindingPattern_l_brack_token)
+        .method(scope, "elements", JsArrayBindingPattern_elements)
+        .method(scope, "r_brack_token", JsArrayBindingPattern_r_brack_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsArrayBindingPatternRestElement>(
+            scope,
+            global,
+            "JsArrayBindingPatternRestElement",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "dotdotdot_token",
+            JsArrayBindingPatternRestElement_dotdotdot_token,
+        )
+        .method(scope, "pattern", JsArrayBindingPatternRestElement_pattern)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsArrayExpression>(scope, global, "JsArrayExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_brack_token", JsArrayExpression_l_brack_token)
+        .method(scope, "elements", JsArrayExpression_elements)
+        .method(scope, "r_brack_token", JsArrayExpression_r_brack_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsArrayHole>(scope, global, "JsArrayHole")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsArrowFunctionExpression>(
+            scope,
+            global,
+            "JsArrowFunctionExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "async_token", JsArrowFunctionExpression_async_token)
+        .method(
+            scope,
+            "type_parameters",
+            JsArrowFunctionExpression_type_parameters,
+        )
+        .method(scope, "parameters", JsArrowFunctionExpression_parameters)
+        .method(
+            scope,
+            "return_type_annotation",
+            JsArrowFunctionExpression_return_type_annotation,
+        )
+        .method(
+            scope,
+            "fat_arrow_token",
+            JsArrowFunctionExpression_fat_arrow_token,
+        )
+        .method(scope, "body", JsArrowFunctionExpression_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsAssignmentExpression>(
+            scope,
+            global,
+            "JsAssignmentExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "left", JsAssignmentExpression_left)
+        .method(
+            scope,
+            "operator_token",
+            JsAssignmentExpression_operator_token,
+        )
+        .method(scope, "right", JsAssignmentExpression_right)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsAssignmentWithDefault>(
+            scope,
+            global,
+            "JsAssignmentWithDefault",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "pattern", JsAssignmentWithDefault_pattern)
+        .method(scope, "eq_token", JsAssignmentWithDefault_eq_token)
+        .method(scope, "default", JsAssignmentWithDefault_default)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsAwaitExpression>(scope, global, "JsAwaitExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "await_token", JsAwaitExpression_await_token)
+        .method(scope, "argument", JsAwaitExpression_argument)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBigintLiteralExpression>(
+            scope,
+            global,
+            "JsBigintLiteralExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsBigintLiteralExpression_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBinaryExpression>(scope, global, "JsBinaryExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "left", JsBinaryExpression_left)
+        .method(scope, "operator_token", JsBinaryExpression_operator_token)
+        .method(scope, "right", JsBinaryExpression_right)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBindingPatternWithDefault>(
+            scope,
+            global,
+            "JsBindingPatternWithDefault",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "pattern", JsBindingPatternWithDefault_pattern)
+        .method(scope, "eq_token", JsBindingPatternWithDefault_eq_token)
+        .method(scope, "default", JsBindingPatternWithDefault_default)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBlockStatement>(scope, global, "JsBlockStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_curly_token", JsBlockStatement_l_curly_token)
+        .method(scope, "statements", JsBlockStatement_statements)
+        .method(scope, "r_curly_token", JsBlockStatement_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBooleanLiteralExpression>(
+            scope,
+            global,
+            "JsBooleanLiteralExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsBooleanLiteralExpression_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBreakStatement>(scope, global, "JsBreakStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "break_token", JsBreakStatement_break_token)
+        .method(scope, "label_token", JsBreakStatement_label_token)
+        .method(scope, "semicolon_token", JsBreakStatement_semicolon_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsCallArguments>(scope, global, "JsCallArguments")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_paren_token", JsCallArguments_l_paren_token)
+        .method(scope, "args", JsCallArguments_args)
+        .method(scope, "r_paren_token", JsCallArguments_r_paren_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsCallExpression>(scope, global, "JsCallExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "callee", JsCallExpression_callee)
+        .method(
+            scope,
+            "optional_chain_token",
+            JsCallExpression_optional_chain_token,
+        )
+        .method(scope, "type_arguments", JsCallExpression_type_arguments)
+        .method(scope, "arguments", JsCallExpression_arguments)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsCaseClause>(scope, global, "JsCaseClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "case_token", JsCaseClause_case_token)
+        .method(scope, "test", JsCaseClause_test)
+        .method(scope, "colon_token", JsCaseClause_colon_token)
+        .method(scope, "consequent", JsCaseClause_consequent)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsCatchClause>(scope, global, "JsCatchClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "catch_token", JsCatchClause_catch_token)
+        .method(scope, "declaration", JsCatchClause_declaration)
+        .method(scope, "body", JsCatchClause_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsCatchDeclaration>(scope, global, "JsCatchDeclaration")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_paren_token", JsCatchDeclaration_l_paren_token)
+        .method(scope, "binding", JsCatchDeclaration_binding)
+        .method(scope, "type_annotation", JsCatchDeclaration_type_annotation)
+        .method(scope, "r_paren_token", JsCatchDeclaration_r_paren_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsClassDeclaration>(scope, global, "JsClassDeclaration")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "decorators", JsClassDeclaration_decorators)
+        .method(scope, "abstract_token", JsClassDeclaration_abstract_token)
+        .method(scope, "class_token", JsClassDeclaration_class_token)
+        .method(scope, "id", JsClassDeclaration_id)
+        .method(scope, "type_parameters", JsClassDeclaration_type_parameters)
+        .method(scope, "extends_clause", JsClassDeclaration_extends_clause)
+        .method(
+            scope,
+            "implements_clause",
+            JsClassDeclaration_implements_clause,
+        )
+        .method(scope, "l_curly_token", JsClassDeclaration_l_curly_token)
+        .method(scope, "members", JsClassDeclaration_members)
+        .method(scope, "r_curly_token", JsClassDeclaration_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsClassExportDefaultDeclaration>(
+            scope,
+            global,
+            "JsClassExportDefaultDeclaration",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "decorators",
+            JsClassExportDefaultDeclaration_decorators,
+        )
+        .method(
+            scope,
+            "abstract_token",
+            JsClassExportDefaultDeclaration_abstract_token,
+        )
+        .method(
+            scope,
+            "class_token",
+            JsClassExportDefaultDeclaration_class_token,
+        )
+        .method(scope, "id", JsClassExportDefaultDeclaration_id)
+        .method(
+            scope,
+            "type_parameters",
+            JsClassExportDefaultDeclaration_type_parameters,
+        )
+        .method(
+            scope,
+            "extends_clause",
+            JsClassExportDefaultDeclaration_extends_clause,
+        )
+        .method(
+            scope,
+            "implements_clause",
+            JsClassExportDefaultDeclaration_implements_clause,
+        )
+        .method(
+            scope,
+            "l_curly_token",
+            JsClassExportDefaultDeclaration_l_curly_token,
+        )
+        .method(scope, "members", JsClassExportDefaultDeclaration_members)
+        .method(
+            scope,
+            "r_curly_token",
+            JsClassExportDefaultDeclaration_r_curly_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsClassExpression>(scope, global, "JsClassExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "decorators", JsClassExpression_decorators)
+        .method(scope, "class_token", JsClassExpression_class_token)
+        .method(scope, "id", JsClassExpression_id)
+        .method(scope, "type_parameters", JsClassExpression_type_parameters)
+        .method(scope, "extends_clause", JsClassExpression_extends_clause)
+        .method(
+            scope,
+            "implements_clause",
+            JsClassExpression_implements_clause,
+        )
+        .method(scope, "l_curly_token", JsClassExpression_l_curly_token)
+        .method(scope, "members", JsClassExpression_members)
+        .method(scope, "r_curly_token", JsClassExpression_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsComputedMemberAssignment>(
+            scope,
+            global,
+            "JsComputedMemberAssignment",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "object", JsComputedMemberAssignment_object)
+        .method(
+            scope,
+            "l_brack_token",
+            JsComputedMemberAssignment_l_brack_token,
+        )
+        .method(scope, "member", JsComputedMemberAssignment_member)
+        .method(
+            scope,
+            "r_brack_token",
+            JsComputedMemberAssignment_r_brack_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsComputedMemberExpression>(
+            scope,
+            global,
+            "JsComputedMemberExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "object", JsComputedMemberExpression_object)
+        .method(
+            scope,
+            "optional_chain_token",
+            JsComputedMemberExpression_optional_chain_token,
+        )
+        .method(
+            scope,
+            "l_brack_token",
+            JsComputedMemberExpression_l_brack_token,
+        )
+        .method(scope, "member", JsComputedMemberExpression_member)
+        .method(
+            scope,
+            "r_brack_token",
+            JsComputedMemberExpression_r_brack_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsComputedMemberName>(scope, global, "JsComputedMemberName")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_brack_token", JsComputedMemberName_l_brack_token)
+        .method(scope, "expression", JsComputedMemberName_expression)
+        .method(scope, "r_brack_token", JsComputedMemberName_r_brack_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsConditionalExpression>(
+            scope,
+            global,
+            "JsConditionalExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "test", JsConditionalExpression_test)
+        .method(
+            scope,
+            "question_mark_token",
+            JsConditionalExpression_question_mark_token,
+        )
+        .method(scope, "consequent", JsConditionalExpression_consequent)
+        .method(scope, "colon_token", JsConditionalExpression_colon_token)
+        .method(scope, "alternate", JsConditionalExpression_alternate)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsConstructorClassMember>(
+            scope,
+            global,
+            "JsConstructorClassMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifiers", JsConstructorClassMember_modifiers)
+        .method(scope, "name", JsConstructorClassMember_name)
+        .method(scope, "parameters", JsConstructorClassMember_parameters)
+        .method(scope, "body", JsConstructorClassMember_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsConstructorParameters>(
+            scope,
+            global,
+            "JsConstructorParameters",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "l_paren_token",
+            JsConstructorParameters_l_paren_token,
+        )
+        .method(scope, "parameters", JsConstructorParameters_parameters)
+        .method(
+            scope,
+            "r_paren_token",
+            JsConstructorParameters_r_paren_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsContinueStatement>(scope, global, "JsContinueStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "continue_token", JsContinueStatement_continue_token)
+        .method(scope, "label_token", JsContinueStatement_label_token)
+        .method(
+            scope,
+            "semicolon_token",
+            JsContinueStatement_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsDebuggerStatement>(scope, global, "JsDebuggerStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "debugger_token", JsDebuggerStatement_debugger_token)
+        .method(
+            scope,
+            "semicolon_token",
+            JsDebuggerStatement_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsDecorator>(scope, global, "JsDecorator")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "at_token", JsDecorator_at_token)
+        .method(scope, "expression", JsDecorator_expression)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsDefaultClause>(scope, global, "JsDefaultClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "default_token", JsDefaultClause_default_token)
+        .method(scope, "colon_token", JsDefaultClause_colon_token)
+        .method(scope, "consequent", JsDefaultClause_consequent)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsDefaultImportSpecifier>(
+            scope,
+            global,
+            "JsDefaultImportSpecifier",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "local_name", JsDefaultImportSpecifier_local_name)
+        .method(
+            scope,
+            "trailing_comma_token",
+            JsDefaultImportSpecifier_trailing_comma_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsDirective>(scope, global, "JsDirective")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsDirective_value_token)
+        .method(scope, "semicolon_token", JsDirective_semicolon_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsDoWhileStatement>(scope, global, "JsDoWhileStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "do_token", JsDoWhileStatement_do_token)
+        .method(scope, "body", JsDoWhileStatement_body)
+        .method(scope, "while_token", JsDoWhileStatement_while_token)
+        .method(scope, "l_paren_token", JsDoWhileStatement_l_paren_token)
+        .method(scope, "test", JsDoWhileStatement_test)
+        .method(scope, "r_paren_token", JsDoWhileStatement_r_paren_token)
+        .method(scope, "semicolon_token", JsDoWhileStatement_semicolon_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsElseClause>(scope, global, "JsElseClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "else_token", JsElseClause_else_token)
+        .method(scope, "alternate", JsElseClause_alternate)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsEmptyClassMember>(scope, global, "JsEmptyClassMember")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "semicolon_token", JsEmptyClassMember_semicolon_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsEmptyStatement>(scope, global, "JsEmptyStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "semicolon_token", JsEmptyStatement_semicolon_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExport>(scope, global, "JsExport")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "decorators", JsExport_decorators)
+        .method(scope, "export_token", JsExport_export_token)
+        .method(scope, "export_clause", JsExport_export_clause)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExportAsClause>(scope, global, "JsExportAsClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "as_token", JsExportAsClause_as_token)
+        .method(scope, "exported_name", JsExportAsClause_exported_name)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExportDefaultDeclarationClause>(
+            scope,
+            global,
+            "JsExportDefaultDeclarationClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "default_token",
+            JsExportDefaultDeclarationClause_default_token,
+        )
+        .method(
+            scope,
+            "declaration",
+            JsExportDefaultDeclarationClause_declaration,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            JsExportDefaultDeclarationClause_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExportDefaultExpressionClause>(
+            scope,
+            global,
+            "JsExportDefaultExpressionClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "default_token",
+            JsExportDefaultExpressionClause_default_token,
+        )
+        .method(
+            scope,
+            "expression",
+            JsExportDefaultExpressionClause_expression,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            JsExportDefaultExpressionClause_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExportFromClause>(scope, global, "JsExportFromClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "type_token", JsExportFromClause_type_token)
+        .method(scope, "star_token", JsExportFromClause_star_token)
+        .method(scope, "export_as", JsExportFromClause_export_as)
+        .method(scope, "from_token", JsExportFromClause_from_token)
+        .method(scope, "source", JsExportFromClause_source)
+        .method(scope, "assertion", JsExportFromClause_assertion)
+        .method(scope, "semicolon_token", JsExportFromClause_semicolon_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExportNamedClause>(scope, global, "JsExportNamedClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "type_token", JsExportNamedClause_type_token)
+        .method(scope, "l_curly_token", JsExportNamedClause_l_curly_token)
+        .method(scope, "specifiers", JsExportNamedClause_specifiers)
+        .method(scope, "r_curly_token", JsExportNamedClause_r_curly_token)
+        .method(
+            scope,
+            "semicolon_token",
+            JsExportNamedClause_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExportNamedFromClause>(
+            scope,
+            global,
+            "JsExportNamedFromClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "type_token", JsExportNamedFromClause_type_token)
+        .method(
+            scope,
+            "l_curly_token",
+            JsExportNamedFromClause_l_curly_token,
+        )
+        .method(scope, "specifiers", JsExportNamedFromClause_specifiers)
+        .method(
+            scope,
+            "r_curly_token",
+            JsExportNamedFromClause_r_curly_token,
+        )
+        .method(scope, "from_token", JsExportNamedFromClause_from_token)
+        .method(scope, "source", JsExportNamedFromClause_source)
+        .method(scope, "assertion", JsExportNamedFromClause_assertion)
+        .method(
+            scope,
+            "semicolon_token",
+            JsExportNamedFromClause_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExportNamedFromSpecifier>(
+            scope,
+            global,
+            "JsExportNamedFromSpecifier",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "type_token", JsExportNamedFromSpecifier_type_token)
+        .method(scope, "source_name", JsExportNamedFromSpecifier_source_name)
+        .method(scope, "export_as", JsExportNamedFromSpecifier_export_as)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExportNamedShorthandSpecifier>(
+            scope,
+            global,
+            "JsExportNamedShorthandSpecifier",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "type_token",
+            JsExportNamedShorthandSpecifier_type_token,
+        )
+        .method(scope, "name", JsExportNamedShorthandSpecifier_name)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExportNamedSpecifier>(
+            scope,
+            global,
+            "JsExportNamedSpecifier",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "type_token", JsExportNamedSpecifier_type_token)
+        .method(scope, "local_name", JsExportNamedSpecifier_local_name)
+        .method(scope, "as_token", JsExportNamedSpecifier_as_token)
+        .method(scope, "exported_name", JsExportNamedSpecifier_exported_name)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExpressionSnipped>(scope, global, "JsExpressionSnipped")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "expression", JsExpressionSnipped_expression)
+        .method(scope, "eof_token", JsExpressionSnipped_eof_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExpressionStatement>(
+            scope,
+            global,
+            "JsExpressionStatement",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "expression", JsExpressionStatement_expression)
+        .method(
+            scope,
+            "semicolon_token",
+            JsExpressionStatement_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExtendsClause>(scope, global, "JsExtendsClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "extends_token", JsExtendsClause_extends_token)
+        .method(scope, "super_class", JsExtendsClause_super_class)
+        .method(scope, "type_arguments", JsExtendsClause_type_arguments)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsFinallyClause>(scope, global, "JsFinallyClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "finally_token", JsFinallyClause_finally_token)
+        .method(scope, "body", JsFinallyClause_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsForInStatement>(scope, global, "JsForInStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "for_token", JsForInStatement_for_token)
+        .method(scope, "l_paren_token", JsForInStatement_l_paren_token)
+        .method(scope, "initializer", JsForInStatement_initializer)
+        .method(scope, "in_token", JsForInStatement_in_token)
+        .method(scope, "expression", JsForInStatement_expression)
+        .method(scope, "r_paren_token", JsForInStatement_r_paren_token)
+        .method(scope, "body", JsForInStatement_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsForOfStatement>(scope, global, "JsForOfStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "for_token", JsForOfStatement_for_token)
+        .method(scope, "await_token", JsForOfStatement_await_token)
+        .method(scope, "l_paren_token", JsForOfStatement_l_paren_token)
+        .method(scope, "initializer", JsForOfStatement_initializer)
+        .method(scope, "of_token", JsForOfStatement_of_token)
+        .method(scope, "expression", JsForOfStatement_expression)
+        .method(scope, "r_paren_token", JsForOfStatement_r_paren_token)
+        .method(scope, "body", JsForOfStatement_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsForStatement>(scope, global, "JsForStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "for_token", JsForStatement_for_token)
+        .method(scope, "l_paren_token", JsForStatement_l_paren_token)
+        .method(scope, "initializer", JsForStatement_initializer)
+        .method(scope, "first_semi_token", JsForStatement_first_semi_token)
+        .method(scope, "test", JsForStatement_test)
+        .method(scope, "second_semi_token", JsForStatement_second_semi_token)
+        .method(scope, "update", JsForStatement_update)
+        .method(scope, "r_paren_token", JsForStatement_r_paren_token)
+        .method(scope, "body", JsForStatement_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsForVariableDeclaration>(
+            scope,
+            global,
+            "JsForVariableDeclaration",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "kind_token", JsForVariableDeclaration_kind_token)
+        .method(scope, "declarator", JsForVariableDeclaration_declarator)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsFormalParameter>(scope, global, "JsFormalParameter")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "decorators", JsFormalParameter_decorators)
+        .method(scope, "binding", JsFormalParameter_binding)
+        .method(
+            scope,
+            "question_mark_token",
+            JsFormalParameter_question_mark_token,
+        )
+        .method(scope, "type_annotation", JsFormalParameter_type_annotation)
+        .method(scope, "initializer", JsFormalParameter_initializer)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsFunctionBody>(scope, global, "JsFunctionBody")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_curly_token", JsFunctionBody_l_curly_token)
+        .method(scope, "directives", JsFunctionBody_directives)
+        .method(scope, "statements", JsFunctionBody_statements)
+        .method(scope, "r_curly_token", JsFunctionBody_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsFunctionDeclaration>(
+            scope,
+            global,
+            "JsFunctionDeclaration",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "async_token", JsFunctionDeclaration_async_token)
+        .method(
+            scope,
+            "function_token",
+            JsFunctionDeclaration_function_token,
+        )
+        .method(scope, "star_token", JsFunctionDeclaration_star_token)
+        .method(scope, "id", JsFunctionDeclaration_id)
+        .method(
+            scope,
+            "type_parameters",
+            JsFunctionDeclaration_type_parameters,
+        )
+        .method(scope, "parameters", JsFunctionDeclaration_parameters)
+        .method(
+            scope,
+            "return_type_annotation",
+            JsFunctionDeclaration_return_type_annotation,
+        )
+        .method(scope, "body", JsFunctionDeclaration_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsFunctionExportDefaultDeclaration>(
+            scope,
+            global,
+            "JsFunctionExportDefaultDeclaration",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "async_token",
+            JsFunctionExportDefaultDeclaration_async_token,
+        )
+        .method(
+            scope,
+            "function_token",
+            JsFunctionExportDefaultDeclaration_function_token,
+        )
+        .method(
+            scope,
+            "star_token",
+            JsFunctionExportDefaultDeclaration_star_token,
+        )
+        .method(scope, "id", JsFunctionExportDefaultDeclaration_id)
+        .method(
+            scope,
+            "type_parameters",
+            JsFunctionExportDefaultDeclaration_type_parameters,
+        )
+        .method(
+            scope,
+            "parameters",
+            JsFunctionExportDefaultDeclaration_parameters,
+        )
+        .method(
+            scope,
+            "return_type_annotation",
+            JsFunctionExportDefaultDeclaration_return_type_annotation,
+        )
+        .method(scope, "body", JsFunctionExportDefaultDeclaration_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsFunctionExpression>(scope, global, "JsFunctionExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "async_token", JsFunctionExpression_async_token)
+        .method(scope, "function_token", JsFunctionExpression_function_token)
+        .method(scope, "star_token", JsFunctionExpression_star_token)
+        .method(scope, "id", JsFunctionExpression_id)
+        .method(
+            scope,
+            "type_parameters",
+            JsFunctionExpression_type_parameters,
+        )
+        .method(scope, "parameters", JsFunctionExpression_parameters)
+        .method(
+            scope,
+            "return_type_annotation",
+            JsFunctionExpression_return_type_annotation,
+        )
+        .method(scope, "body", JsFunctionExpression_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsGetterClassMember>(scope, global, "JsGetterClassMember")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifiers", JsGetterClassMember_modifiers)
+        .method(scope, "get_token", JsGetterClassMember_get_token)
+        .method(scope, "name", JsGetterClassMember_name)
+        .method(scope, "l_paren_token", JsGetterClassMember_l_paren_token)
+        .method(scope, "r_paren_token", JsGetterClassMember_r_paren_token)
+        .method(scope, "return_type", JsGetterClassMember_return_type)
+        .method(scope, "body", JsGetterClassMember_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsGetterObjectMember>(scope, global, "JsGetterObjectMember")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "get_token", JsGetterObjectMember_get_token)
+        .method(scope, "name", JsGetterObjectMember_name)
+        .method(scope, "l_paren_token", JsGetterObjectMember_l_paren_token)
+        .method(scope, "r_paren_token", JsGetterObjectMember_r_paren_token)
+        .method(scope, "return_type", JsGetterObjectMember_return_type)
+        .method(scope, "body", JsGetterObjectMember_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsIdentifierAssignment>(
+            scope,
+            global,
+            "JsIdentifierAssignment",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "name_token", JsIdentifierAssignment_name_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsIdentifierBinding>(scope, global, "JsIdentifierBinding")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "name_token", JsIdentifierBinding_name_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsIdentifierExpression>(
+            scope,
+            global,
+            "JsIdentifierExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "name", JsIdentifierExpression_name)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsIfStatement>(scope, global, "JsIfStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "if_token", JsIfStatement_if_token)
+        .method(scope, "l_paren_token", JsIfStatement_l_paren_token)
+        .method(scope, "test", JsIfStatement_test)
+        .method(scope, "r_paren_token", JsIfStatement_r_paren_token)
+        .method(scope, "consequent", JsIfStatement_consequent)
+        .method(scope, "else_clause", JsIfStatement_else_clause)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsImport>(scope, global, "JsImport")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "import_token", JsImport_import_token)
+        .method(scope, "import_clause", JsImport_import_clause)
+        .method(scope, "semicolon_token", JsImport_semicolon_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsImportAssertion>(scope, global, "JsImportAssertion")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "assertion_kind", JsImportAssertion_assertion_kind)
+        .method(scope, "l_curly_token", JsImportAssertion_l_curly_token)
+        .method(scope, "assertions", JsImportAssertion_assertions)
+        .method(scope, "r_curly_token", JsImportAssertion_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsImportAssertionEntry>(
+            scope,
+            global,
+            "JsImportAssertionEntry",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "key", JsImportAssertionEntry_key)
+        .method(scope, "colon_token", JsImportAssertionEntry_colon_token)
+        .method(scope, "value_token", JsImportAssertionEntry_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsImportBareClause>(scope, global, "JsImportBareClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "source", JsImportBareClause_source)
+        .method(scope, "assertion", JsImportBareClause_assertion)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsImportCallExpression>(
+            scope,
+            global,
+            "JsImportCallExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "import_token", JsImportCallExpression_import_token)
+        .method(scope, "arguments", JsImportCallExpression_arguments)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsImportDefaultClause>(
+            scope,
+            global,
+            "JsImportDefaultClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "type_token", JsImportDefaultClause_type_token)
+        .method(scope, "local_name", JsImportDefaultClause_local_name)
+        .method(scope, "from_token", JsImportDefaultClause_from_token)
+        .method(scope, "source", JsImportDefaultClause_source)
+        .method(scope, "assertion", JsImportDefaultClause_assertion)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsImportMetaExpression>(
+            scope,
+            global,
+            "JsImportMetaExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "import_token", JsImportMetaExpression_import_token)
+        .method(scope, "dot_token", JsImportMetaExpression_dot_token)
+        .method(scope, "meta_token", JsImportMetaExpression_meta_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsImportNamedClause>(scope, global, "JsImportNamedClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "type_token", JsImportNamedClause_type_token)
+        .method(
+            scope,
+            "default_specifier",
+            JsImportNamedClause_default_specifier,
+        )
+        .method(scope, "named_import", JsImportNamedClause_named_import)
+        .method(scope, "from_token", JsImportNamedClause_from_token)
+        .method(scope, "source", JsImportNamedClause_source)
+        .method(scope, "assertion", JsImportNamedClause_assertion)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsImportNamespaceClause>(
+            scope,
+            global,
+            "JsImportNamespaceClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "type_token", JsImportNamespaceClause_type_token)
+        .method(scope, "star_token", JsImportNamespaceClause_star_token)
+        .method(scope, "as_token", JsImportNamespaceClause_as_token)
+        .method(scope, "local_name", JsImportNamespaceClause_local_name)
+        .method(scope, "from_token", JsImportNamespaceClause_from_token)
+        .method(scope, "source", JsImportNamespaceClause_source)
+        .method(scope, "assertion", JsImportNamespaceClause_assertion)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsInExpression>(scope, global, "JsInExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "property", JsInExpression_property)
+        .method(scope, "in_token", JsInExpression_in_token)
+        .method(scope, "object", JsInExpression_object)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsInitializerClause>(scope, global, "JsInitializerClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "eq_token", JsInitializerClause_eq_token)
+        .method(scope, "expression", JsInitializerClause_expression)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsInstanceofExpression>(
+            scope,
+            global,
+            "JsInstanceofExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "left", JsInstanceofExpression_left)
+        .method(
+            scope,
+            "instanceof_token",
+            JsInstanceofExpression_instanceof_token,
+        )
+        .method(scope, "right", JsInstanceofExpression_right)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsLabeledStatement>(scope, global, "JsLabeledStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "label_token", JsLabeledStatement_label_token)
+        .method(scope, "colon_token", JsLabeledStatement_colon_token)
+        .method(scope, "body", JsLabeledStatement_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsLiteralExportName>(scope, global, "JsLiteralExportName")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value", JsLiteralExportName_value)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsLiteralMemberName>(scope, global, "JsLiteralMemberName")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value", JsLiteralMemberName_value)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsLogicalExpression>(scope, global, "JsLogicalExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "left", JsLogicalExpression_left)
+        .method(scope, "operator_token", JsLogicalExpression_operator_token)
+        .method(scope, "right", JsLogicalExpression_right)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsMethodClassMember>(scope, global, "JsMethodClassMember")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifiers", JsMethodClassMember_modifiers)
+        .method(scope, "async_token", JsMethodClassMember_async_token)
+        .method(scope, "star_token", JsMethodClassMember_star_token)
+        .method(scope, "name", JsMethodClassMember_name)
+        .method(
+            scope,
+            "question_mark_token",
+            JsMethodClassMember_question_mark_token,
+        )
+        .method(
+            scope,
+            "type_parameters",
+            JsMethodClassMember_type_parameters,
+        )
+        .method(scope, "parameters", JsMethodClassMember_parameters)
+        .method(
+            scope,
+            "return_type_annotation",
+            JsMethodClassMember_return_type_annotation,
+        )
+        .method(scope, "body", JsMethodClassMember_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsMethodObjectMember>(scope, global, "JsMethodObjectMember")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "async_token", JsMethodObjectMember_async_token)
+        .method(scope, "star_token", JsMethodObjectMember_star_token)
+        .method(scope, "name", JsMethodObjectMember_name)
+        .method(
+            scope,
+            "type_parameters",
+            JsMethodObjectMember_type_parameters,
+        )
+        .method(scope, "parameters", JsMethodObjectMember_parameters)
+        .method(
+            scope,
+            "return_type_annotation",
+            JsMethodObjectMember_return_type_annotation,
+        )
+        .method(scope, "body", JsMethodObjectMember_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsModule>(scope, global, "JsModule")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "interpreter_token", JsModule_interpreter_token)
+        .method(scope, "directives", JsModule_directives)
+        .method(scope, "items", JsModule_items)
+        .method(scope, "eof_token", JsModule_eof_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsModuleSource>(scope, global, "JsModuleSource")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsModuleSource_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsName>(scope, global, "JsName")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsName_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsNamedImportSpecifier>(
+            scope,
+            global,
+            "JsNamedImportSpecifier",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "type_token", JsNamedImportSpecifier_type_token)
+        .method(scope, "name", JsNamedImportSpecifier_name)
+        .method(scope, "as_token", JsNamedImportSpecifier_as_token)
+        .method(scope, "local_name", JsNamedImportSpecifier_local_name)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsNamedImportSpecifiers>(
+            scope,
+            global,
+            "JsNamedImportSpecifiers",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "l_curly_token",
+            JsNamedImportSpecifiers_l_curly_token,
+        )
+        .method(scope, "specifiers", JsNamedImportSpecifiers_specifiers)
+        .method(
+            scope,
+            "r_curly_token",
+            JsNamedImportSpecifiers_r_curly_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsNamespaceImportSpecifier>(
+            scope,
+            global,
+            "JsNamespaceImportSpecifier",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "star_token", JsNamespaceImportSpecifier_star_token)
+        .method(scope, "as_token", JsNamespaceImportSpecifier_as_token)
+        .method(scope, "local_name", JsNamespaceImportSpecifier_local_name)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsNewExpression>(scope, global, "JsNewExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "new_token", JsNewExpression_new_token)
+        .method(scope, "callee", JsNewExpression_callee)
+        .method(scope, "type_arguments", JsNewExpression_type_arguments)
+        .method(scope, "arguments", JsNewExpression_arguments)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsNewTargetExpression>(
+            scope,
+            global,
+            "JsNewTargetExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "new_token", JsNewTargetExpression_new_token)
+        .method(scope, "dot_token", JsNewTargetExpression_dot_token)
+        .method(scope, "target_token", JsNewTargetExpression_target_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsNullLiteralExpression>(
+            scope,
+            global,
+            "JsNullLiteralExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsNullLiteralExpression_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsNumberLiteralExpression>(
+            scope,
+            global,
+            "JsNumberLiteralExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsNumberLiteralExpression_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsObjectAssignmentPattern>(
+            scope,
+            global,
+            "JsObjectAssignmentPattern",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "l_curly_token",
+            JsObjectAssignmentPattern_l_curly_token,
+        )
+        .method(scope, "properties", JsObjectAssignmentPattern_properties)
+        .method(
+            scope,
+            "r_curly_token",
+            JsObjectAssignmentPattern_r_curly_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsObjectAssignmentPatternProperty>(
+            scope,
+            global,
+            "JsObjectAssignmentPatternProperty",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "member", JsObjectAssignmentPatternProperty_member)
+        .method(
+            scope,
+            "colon_token",
+            JsObjectAssignmentPatternProperty_colon_token,
+        )
+        .method(scope, "pattern", JsObjectAssignmentPatternProperty_pattern)
+        .method(scope, "init", JsObjectAssignmentPatternProperty_init)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsObjectAssignmentPatternRest>(
+            scope,
+            global,
+            "JsObjectAssignmentPatternRest",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "dotdotdot_token",
+            JsObjectAssignmentPatternRest_dotdotdot_token,
+        )
+        .method(scope, "target", JsObjectAssignmentPatternRest_target)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsObjectAssignmentPatternShorthandProperty>(
+            scope,
+            global,
+            "JsObjectAssignmentPatternShorthandProperty",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "identifier",
+            JsObjectAssignmentPatternShorthandProperty_identifier,
+        )
+        .method(
+            scope,
+            "init",
+            JsObjectAssignmentPatternShorthandProperty_init,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsObjectBindingPattern>(
+            scope,
+            global,
+            "JsObjectBindingPattern",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_curly_token", JsObjectBindingPattern_l_curly_token)
+        .method(scope, "properties", JsObjectBindingPattern_properties)
+        .method(scope, "r_curly_token", JsObjectBindingPattern_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsObjectBindingPatternProperty>(
+            scope,
+            global,
+            "JsObjectBindingPatternProperty",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "member", JsObjectBindingPatternProperty_member)
+        .method(
+            scope,
+            "colon_token",
+            JsObjectBindingPatternProperty_colon_token,
+        )
+        .method(scope, "pattern", JsObjectBindingPatternProperty_pattern)
+        .method(scope, "init", JsObjectBindingPatternProperty_init)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsObjectBindingPatternRest>(
+            scope,
+            global,
+            "JsObjectBindingPatternRest",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "dotdotdot_token",
+            JsObjectBindingPatternRest_dotdotdot_token,
+        )
+        .method(scope, "binding", JsObjectBindingPatternRest_binding)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsObjectBindingPatternShorthandProperty>(
+            scope,
+            global,
+            "JsObjectBindingPatternShorthandProperty",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "identifier",
+            JsObjectBindingPatternShorthandProperty_identifier,
+        )
+        .method(scope, "init", JsObjectBindingPatternShorthandProperty_init)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsObjectExpression>(scope, global, "JsObjectExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_curly_token", JsObjectExpression_l_curly_token)
+        .method(scope, "members", JsObjectExpression_members)
+        .method(scope, "r_curly_token", JsObjectExpression_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsParameters>(scope, global, "JsParameters")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_paren_token", JsParameters_l_paren_token)
+        .method(scope, "items", JsParameters_items)
+        .method(scope, "r_paren_token", JsParameters_r_paren_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsParenthesizedAssignment>(
+            scope,
+            global,
+            "JsParenthesizedAssignment",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "l_paren_token",
+            JsParenthesizedAssignment_l_paren_token,
+        )
+        .method(scope, "assignment", JsParenthesizedAssignment_assignment)
+        .method(
+            scope,
+            "r_paren_token",
+            JsParenthesizedAssignment_r_paren_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsParenthesizedExpression>(
+            scope,
+            global,
+            "JsParenthesizedExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "l_paren_token",
+            JsParenthesizedExpression_l_paren_token,
+        )
+        .method(scope, "expression", JsParenthesizedExpression_expression)
+        .method(
+            scope,
+            "r_paren_token",
+            JsParenthesizedExpression_r_paren_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsPostUpdateExpression>(
+            scope,
+            global,
+            "JsPostUpdateExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "operand", JsPostUpdateExpression_operand)
+        .method(
+            scope,
+            "operator_token",
+            JsPostUpdateExpression_operator_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsPreUpdateExpression>(
+            scope,
+            global,
+            "JsPreUpdateExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "operator_token",
+            JsPreUpdateExpression_operator_token,
+        )
+        .method(scope, "operand", JsPreUpdateExpression_operand)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsPrivateClassMemberName>(
+            scope,
+            global,
+            "JsPrivateClassMemberName",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "hash_token", JsPrivateClassMemberName_hash_token)
+        .method(scope, "id_token", JsPrivateClassMemberName_id_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsPrivateName>(scope, global, "JsPrivateName")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "hash_token", JsPrivateName_hash_token)
+        .method(scope, "value_token", JsPrivateName_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsPropertyClassMember>(
+            scope,
+            global,
+            "JsPropertyClassMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifiers", JsPropertyClassMember_modifiers)
+        .method(scope, "name", JsPropertyClassMember_name)
+        .method(
+            scope,
+            "property_annotation",
+            JsPropertyClassMember_property_annotation,
+        )
+        .method(scope, "value", JsPropertyClassMember_value)
+        .method(
+            scope,
+            "semicolon_token",
+            JsPropertyClassMember_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsPropertyObjectMember>(
+            scope,
+            global,
+            "JsPropertyObjectMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "name", JsPropertyObjectMember_name)
+        .method(scope, "colon_token", JsPropertyObjectMember_colon_token)
+        .method(scope, "value", JsPropertyObjectMember_value)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsReferenceIdentifier>(
+            scope,
+            global,
+            "JsReferenceIdentifier",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsReferenceIdentifier_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsRegexLiteralExpression>(
+            scope,
+            global,
+            "JsRegexLiteralExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsRegexLiteralExpression_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsRestParameter>(scope, global, "JsRestParameter")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "decorators", JsRestParameter_decorators)
+        .method(scope, "dotdotdot_token", JsRestParameter_dotdotdot_token)
+        .method(scope, "binding", JsRestParameter_binding)
+        .method(scope, "type_annotation", JsRestParameter_type_annotation)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsReturnStatement>(scope, global, "JsReturnStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "return_token", JsReturnStatement_return_token)
+        .method(scope, "argument", JsReturnStatement_argument)
+        .method(scope, "semicolon_token", JsReturnStatement_semicolon_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsScript>(scope, global, "JsScript")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "interpreter_token", JsScript_interpreter_token)
+        .method(scope, "directives", JsScript_directives)
+        .method(scope, "statements", JsScript_statements)
+        .method(scope, "eof_token", JsScript_eof_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsSequenceExpression>(scope, global, "JsSequenceExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "left", JsSequenceExpression_left)
+        .method(scope, "comma_token", JsSequenceExpression_comma_token)
+        .method(scope, "right", JsSequenceExpression_right)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsSetterClassMember>(scope, global, "JsSetterClassMember")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifiers", JsSetterClassMember_modifiers)
+        .method(scope, "set_token", JsSetterClassMember_set_token)
+        .method(scope, "name", JsSetterClassMember_name)
+        .method(scope, "l_paren_token", JsSetterClassMember_l_paren_token)
+        .method(scope, "parameter", JsSetterClassMember_parameter)
+        .method(scope, "r_paren_token", JsSetterClassMember_r_paren_token)
+        .method(scope, "body", JsSetterClassMember_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsSetterObjectMember>(scope, global, "JsSetterObjectMember")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "set_token", JsSetterObjectMember_set_token)
+        .method(scope, "name", JsSetterObjectMember_name)
+        .method(scope, "l_paren_token", JsSetterObjectMember_l_paren_token)
+        .method(scope, "parameter", JsSetterObjectMember_parameter)
+        .method(scope, "r_paren_token", JsSetterObjectMember_r_paren_token)
+        .method(scope, "body", JsSetterObjectMember_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsShorthandNamedImportSpecifier>(
+            scope,
+            global,
+            "JsShorthandNamedImportSpecifier",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "type_token",
+            JsShorthandNamedImportSpecifier_type_token,
+        )
+        .method(
+            scope,
+            "local_name",
+            JsShorthandNamedImportSpecifier_local_name,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsShorthandPropertyObjectMember>(
+            scope,
+            global,
+            "JsShorthandPropertyObjectMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "name", JsShorthandPropertyObjectMember_name)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsSpread>(scope, global, "JsSpread")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "dotdotdot_token", JsSpread_dotdotdot_token)
+        .method(scope, "argument", JsSpread_argument)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsStaticInitializationBlockClassMember>(
+            scope,
+            global,
+            "JsStaticInitializationBlockClassMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "static_token",
+            JsStaticInitializationBlockClassMember_static_token,
+        )
+        .method(
+            scope,
+            "l_curly_token",
+            JsStaticInitializationBlockClassMember_l_curly_token,
+        )
+        .method(
+            scope,
+            "statements",
+            JsStaticInitializationBlockClassMember_statements,
+        )
+        .method(
+            scope,
+            "r_curly_token",
+            JsStaticInitializationBlockClassMember_r_curly_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsStaticMemberAssignment>(
+            scope,
+            global,
+            "JsStaticMemberAssignment",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "object", JsStaticMemberAssignment_object)
+        .method(scope, "dot_token", JsStaticMemberAssignment_dot_token)
+        .method(scope, "member", JsStaticMemberAssignment_member)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsStaticMemberExpression>(
+            scope,
+            global,
+            "JsStaticMemberExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "object", JsStaticMemberExpression_object)
+        .method(
+            scope,
+            "operator_token",
+            JsStaticMemberExpression_operator_token,
+        )
+        .method(scope, "member", JsStaticMemberExpression_member)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsStaticModifier>(scope, global, "JsStaticModifier")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifier_token", JsStaticModifier_modifier_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsStringLiteralExpression>(
+            scope,
+            global,
+            "JsStringLiteralExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsStringLiteralExpression_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsSuperExpression>(scope, global, "JsSuperExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "super_token", JsSuperExpression_super_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsSwitchStatement>(scope, global, "JsSwitchStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "switch_token", JsSwitchStatement_switch_token)
+        .method(scope, "l_paren_token", JsSwitchStatement_l_paren_token)
+        .method(scope, "discriminant", JsSwitchStatement_discriminant)
+        .method(scope, "r_paren_token", JsSwitchStatement_r_paren_token)
+        .method(scope, "l_curly_token", JsSwitchStatement_l_curly_token)
+        .method(scope, "cases", JsSwitchStatement_cases)
+        .method(scope, "r_curly_token", JsSwitchStatement_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsTemplateChunkElement>(
+            scope,
+            global,
+            "JsTemplateChunkElement",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "template_chunk_token",
+            JsTemplateChunkElement_template_chunk_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsTemplateElement>(scope, global, "JsTemplateElement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "dollar_curly_token",
+            JsTemplateElement_dollar_curly_token,
+        )
+        .method(scope, "expression", JsTemplateElement_expression)
+        .method(scope, "r_curly_token", JsTemplateElement_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsTemplateExpression>(scope, global, "JsTemplateExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "tag", JsTemplateExpression_tag)
+        .method(scope, "type_arguments", JsTemplateExpression_type_arguments)
+        .method(scope, "l_tick_token", JsTemplateExpression_l_tick_token)
+        .method(scope, "elements", JsTemplateExpression_elements)
+        .method(scope, "r_tick_token", JsTemplateExpression_r_tick_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsThisExpression>(scope, global, "JsThisExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "this_token", JsThisExpression_this_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsThrowStatement>(scope, global, "JsThrowStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "throw_token", JsThrowStatement_throw_token)
+        .method(scope, "argument", JsThrowStatement_argument)
+        .method(scope, "semicolon_token", JsThrowStatement_semicolon_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsTryFinallyStatement>(
+            scope,
+            global,
+            "JsTryFinallyStatement",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "try_token", JsTryFinallyStatement_try_token)
+        .method(scope, "body", JsTryFinallyStatement_body)
+        .method(scope, "catch_clause", JsTryFinallyStatement_catch_clause)
+        .method(
+            scope,
+            "finally_clause",
+            JsTryFinallyStatement_finally_clause,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsTryStatement>(scope, global, "JsTryStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "try_token", JsTryStatement_try_token)
+        .method(scope, "body", JsTryStatement_body)
+        .method(scope, "catch_clause", JsTryStatement_catch_clause)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsUnaryExpression>(scope, global, "JsUnaryExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "operator_token", JsUnaryExpression_operator_token)
+        .method(scope, "argument", JsUnaryExpression_argument)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsVariableDeclaration>(
+            scope,
+            global,
+            "JsVariableDeclaration",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "kind", JsVariableDeclaration_kind)
+        .method(scope, "declarators", JsVariableDeclaration_declarators)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsVariableDeclarationClause>(
+            scope,
+            global,
+            "JsVariableDeclarationClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "declaration",
+            JsVariableDeclarationClause_declaration,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            JsVariableDeclarationClause_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsVariableDeclarator>(scope, global, "JsVariableDeclarator")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "id", JsVariableDeclarator_id)
+        .method(
+            scope,
+            "variable_annotation",
+            JsVariableDeclarator_variable_annotation,
+        )
+        .method(scope, "initializer", JsVariableDeclarator_initializer)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsVariableStatement>(scope, global, "JsVariableStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "declaration", JsVariableStatement_declaration)
+        .method(
+            scope,
+            "semicolon_token",
+            JsVariableStatement_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsWhileStatement>(scope, global, "JsWhileStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "while_token", JsWhileStatement_while_token)
+        .method(scope, "l_paren_token", JsWhileStatement_l_paren_token)
+        .method(scope, "test", JsWhileStatement_test)
+        .method(scope, "r_paren_token", JsWhileStatement_r_paren_token)
+        .method(scope, "body", JsWhileStatement_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsWithStatement>(scope, global, "JsWithStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "with_token", JsWithStatement_with_token)
+        .method(scope, "l_paren_token", JsWithStatement_l_paren_token)
+        .method(scope, "object", JsWithStatement_object)
+        .method(scope, "r_paren_token", JsWithStatement_r_paren_token)
+        .method(scope, "body", JsWithStatement_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsYieldArgument>(scope, global, "JsYieldArgument")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "star_token", JsYieldArgument_star_token)
+        .method(scope, "expression", JsYieldArgument_expression)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsYieldExpression>(scope, global, "JsYieldExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "yield_token", JsYieldExpression_yield_token)
+        .method(scope, "argument", JsYieldExpression_argument)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxAttribute>(scope, global, "JsxAttribute")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "name", JsxAttribute_name)
+        .method(scope, "initializer", JsxAttribute_initializer)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxAttributeInitializerClause>(
+            scope,
+            global,
+            "JsxAttributeInitializerClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "eq_token", JsxAttributeInitializerClause_eq_token)
+        .method(scope, "value", JsxAttributeInitializerClause_value)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxClosingElement>(scope, global, "JsxClosingElement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_angle_token", JsxClosingElement_l_angle_token)
+        .method(scope, "slash_token", JsxClosingElement_slash_token)
+        .method(scope, "name", JsxClosingElement_name)
+        .method(scope, "r_angle_token", JsxClosingElement_r_angle_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxClosingFragment>(scope, global, "JsxClosingFragment")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_angle_token", JsxClosingFragment_l_angle_token)
+        .method(scope, "slash_token", JsxClosingFragment_slash_token)
+        .method(scope, "r_angle_token", JsxClosingFragment_r_angle_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxElement>(scope, global, "JsxElement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "opening_element", JsxElement_opening_element)
+        .method(scope, "children", JsxElement_children)
+        .method(scope, "closing_element", JsxElement_closing_element)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxExpressionAttributeValue>(
+            scope,
+            global,
+            "JsxExpressionAttributeValue",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "l_curly_token",
+            JsxExpressionAttributeValue_l_curly_token,
+        )
+        .method(scope, "expression", JsxExpressionAttributeValue_expression)
+        .method(
+            scope,
+            "r_curly_token",
+            JsxExpressionAttributeValue_r_curly_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxExpressionChild>(scope, global, "JsxExpressionChild")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_curly_token", JsxExpressionChild_l_curly_token)
+        .method(scope, "expression", JsxExpressionChild_expression)
+        .method(scope, "r_curly_token", JsxExpressionChild_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxFragment>(scope, global, "JsxFragment")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "opening_fragment", JsxFragment_opening_fragment)
+        .method(scope, "children", JsxFragment_children)
+        .method(scope, "closing_fragment", JsxFragment_closing_fragment)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxMemberName>(scope, global, "JsxMemberName")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "object", JsxMemberName_object)
+        .method(scope, "dot_token", JsxMemberName_dot_token)
+        .method(scope, "member", JsxMemberName_member)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxName>(scope, global, "JsxName")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsxName_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxNamespaceName>(scope, global, "JsxNamespaceName")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "namespace", JsxNamespaceName_namespace)
+        .method(scope, "colon_token", JsxNamespaceName_colon_token)
+        .method(scope, "name", JsxNamespaceName_name)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxOpeningElement>(scope, global, "JsxOpeningElement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_angle_token", JsxOpeningElement_l_angle_token)
+        .method(scope, "name", JsxOpeningElement_name)
+        .method(scope, "type_arguments", JsxOpeningElement_type_arguments)
+        .method(scope, "attributes", JsxOpeningElement_attributes)
+        .method(scope, "r_angle_token", JsxOpeningElement_r_angle_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxOpeningFragment>(scope, global, "JsxOpeningFragment")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_angle_token", JsxOpeningFragment_l_angle_token)
+        .method(scope, "r_angle_token", JsxOpeningFragment_r_angle_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxReferenceIdentifier>(
+            scope,
+            global,
+            "JsxReferenceIdentifier",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsxReferenceIdentifier_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxSelfClosingElement>(
+            scope,
+            global,
+            "JsxSelfClosingElement",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_angle_token", JsxSelfClosingElement_l_angle_token)
+        .method(scope, "name", JsxSelfClosingElement_name)
+        .method(
+            scope,
+            "type_arguments",
+            JsxSelfClosingElement_type_arguments,
+        )
+        .method(scope, "attributes", JsxSelfClosingElement_attributes)
+        .method(scope, "slash_token", JsxSelfClosingElement_slash_token)
+        .method(scope, "r_angle_token", JsxSelfClosingElement_r_angle_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxSpreadAttribute>(scope, global, "JsxSpreadAttribute")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_curly_token", JsxSpreadAttribute_l_curly_token)
+        .method(scope, "dotdotdot_token", JsxSpreadAttribute_dotdotdot_token)
+        .method(scope, "argument", JsxSpreadAttribute_argument)
+        .method(scope, "r_curly_token", JsxSpreadAttribute_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxSpreadChild>(scope, global, "JsxSpreadChild")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_curly_token", JsxSpreadChild_l_curly_token)
+        .method(scope, "dotdotdot_token", JsxSpreadChild_dotdotdot_token)
+        .method(scope, "expression", JsxSpreadChild_expression)
+        .method(scope, "r_curly_token", JsxSpreadChild_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxString>(scope, global, "JsxString")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsxString_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxTagExpression>(scope, global, "JsxTagExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "tag", JsxTagExpression_tag)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxText>(scope, global, "JsxText")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "value_token", JsxText_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsAbstractModifier>(scope, global, "TsAbstractModifier")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifier_token", TsAbstractModifier_modifier_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsAccessibilityModifier>(
+            scope,
+            global,
+            "TsAccessibilityModifier",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "modifier_token",
+            TsAccessibilityModifier_modifier_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsAnyType>(scope, global, "TsAnyType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "any_token", TsAnyType_any_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsArrayType>(scope, global, "TsArrayType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "element_type", TsArrayType_element_type)
+        .method(scope, "l_brack_token", TsArrayType_l_brack_token)
+        .method(scope, "r_brack_token", TsArrayType_r_brack_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsAsAssignment>(scope, global, "TsAsAssignment")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "assignment", TsAsAssignment_assignment)
+        .method(scope, "as_token", TsAsAssignment_as_token)
+        .method(scope, "ty", TsAsAssignment_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsAsExpression>(scope, global, "TsAsExpression")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "expression", TsAsExpression_expression)
+        .method(scope, "as_token", TsAsExpression_as_token)
+        .method(scope, "ty", TsAsExpression_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsAssertsCondition>(scope, global, "TsAssertsCondition")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "is_token", TsAssertsCondition_is_token)
+        .method(scope, "ty", TsAssertsCondition_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsAssertsReturnType>(scope, global, "TsAssertsReturnType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "asserts_token", TsAssertsReturnType_asserts_token)
+        .method(scope, "parameter_name", TsAssertsReturnType_parameter_name)
+        .method(scope, "predicate", TsAssertsReturnType_predicate)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsBigintLiteralType>(scope, global, "TsBigintLiteralType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "minus_token", TsBigintLiteralType_minus_token)
+        .method(scope, "literal_token", TsBigintLiteralType_literal_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsBigintType>(scope, global, "TsBigintType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "bigint_token", TsBigintType_bigint_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsBooleanLiteralType>(scope, global, "TsBooleanLiteralType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "literal", TsBooleanLiteralType_literal)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsBooleanType>(scope, global, "TsBooleanType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "boolean_token", TsBooleanType_boolean_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsCallSignatureTypeMember>(
+            scope,
+            global,
+            "TsCallSignatureTypeMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "type_parameters",
+            TsCallSignatureTypeMember_type_parameters,
+        )
+        .method(scope, "parameters", TsCallSignatureTypeMember_parameters)
+        .method(
+            scope,
+            "return_type_annotation",
+            TsCallSignatureTypeMember_return_type_annotation,
+        )
+        .method(
+            scope,
+            "separator_token",
+            TsCallSignatureTypeMember_separator_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsConditionalType>(scope, global, "TsConditionalType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "check_type", TsConditionalType_check_type)
+        .method(scope, "extends_token", TsConditionalType_extends_token)
+        .method(scope, "extends_type", TsConditionalType_extends_type)
+        .method(
+            scope,
+            "question_mark_token",
+            TsConditionalType_question_mark_token,
+        )
+        .method(scope, "true_type", TsConditionalType_true_type)
+        .method(scope, "colon_token", TsConditionalType_colon_token)
+        .method(scope, "false_type", TsConditionalType_false_type)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsConstModifier>(scope, global, "TsConstModifier")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifier_token", TsConstModifier_modifier_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsConstructSignatureTypeMember>(
+            scope,
+            global,
+            "TsConstructSignatureTypeMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "new_token", TsConstructSignatureTypeMember_new_token)
+        .method(
+            scope,
+            "type_parameters",
+            TsConstructSignatureTypeMember_type_parameters,
+        )
+        .method(
+            scope,
+            "parameters",
+            TsConstructSignatureTypeMember_parameters,
+        )
+        .method(
+            scope,
+            "type_annotation",
+            TsConstructSignatureTypeMember_type_annotation,
+        )
+        .method(
+            scope,
+            "separator_token",
+            TsConstructSignatureTypeMember_separator_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsConstructorSignatureClassMember>(
+            scope,
+            global,
+            "TsConstructorSignatureClassMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "modifiers",
+            TsConstructorSignatureClassMember_modifiers,
+        )
+        .method(scope, "name", TsConstructorSignatureClassMember_name)
+        .method(
+            scope,
+            "parameters",
+            TsConstructorSignatureClassMember_parameters,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            TsConstructorSignatureClassMember_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsConstructorType>(scope, global, "TsConstructorType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "abstract_token", TsConstructorType_abstract_token)
+        .method(scope, "new_token", TsConstructorType_new_token)
+        .method(scope, "type_parameters", TsConstructorType_type_parameters)
+        .method(scope, "parameters", TsConstructorType_parameters)
+        .method(scope, "fat_arrow_token", TsConstructorType_fat_arrow_token)
+        .method(scope, "return_type", TsConstructorType_return_type)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsDeclareFunctionDeclaration>(
+            scope,
+            global,
+            "TsDeclareFunctionDeclaration",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "async_token",
+            TsDeclareFunctionDeclaration_async_token,
+        )
+        .method(
+            scope,
+            "function_token",
+            TsDeclareFunctionDeclaration_function_token,
+        )
+        .method(scope, "id", TsDeclareFunctionDeclaration_id)
+        .method(
+            scope,
+            "type_parameters",
+            TsDeclareFunctionDeclaration_type_parameters,
+        )
+        .method(scope, "parameters", TsDeclareFunctionDeclaration_parameters)
+        .method(
+            scope,
+            "return_type_annotation",
+            TsDeclareFunctionDeclaration_return_type_annotation,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            TsDeclareFunctionDeclaration_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsDeclareFunctionExportDefaultDeclaration>(
+            scope,
+            global,
+            "TsDeclareFunctionExportDefaultDeclaration",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "async_token",
+            TsDeclareFunctionExportDefaultDeclaration_async_token,
+        )
+        .method(
+            scope,
+            "function_token",
+            TsDeclareFunctionExportDefaultDeclaration_function_token,
+        )
+        .method(scope, "id", TsDeclareFunctionExportDefaultDeclaration_id)
+        .method(
+            scope,
+            "type_parameters",
+            TsDeclareFunctionExportDefaultDeclaration_type_parameters,
+        )
+        .method(
+            scope,
+            "parameters",
+            TsDeclareFunctionExportDefaultDeclaration_parameters,
+        )
+        .method(
+            scope,
+            "return_type_annotation",
+            TsDeclareFunctionExportDefaultDeclaration_return_type_annotation,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            TsDeclareFunctionExportDefaultDeclaration_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsDeclareModifier>(scope, global, "TsDeclareModifier")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifier_token", TsDeclareModifier_modifier_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsDeclareStatement>(scope, global, "TsDeclareStatement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "declare_token", TsDeclareStatement_declare_token)
+        .method(scope, "declaration", TsDeclareStatement_declaration)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsDefaultTypeClause>(scope, global, "TsDefaultTypeClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "eq_token", TsDefaultTypeClause_eq_token)
+        .method(scope, "ty", TsDefaultTypeClause_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsDefinitePropertyAnnotation>(
+            scope,
+            global,
+            "TsDefinitePropertyAnnotation",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "excl_token", TsDefinitePropertyAnnotation_excl_token)
+        .method(
+            scope,
+            "type_annotation",
+            TsDefinitePropertyAnnotation_type_annotation,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsDefiniteVariableAnnotation>(
+            scope,
+            global,
+            "TsDefiniteVariableAnnotation",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "excl_token", TsDefiniteVariableAnnotation_excl_token)
+        .method(
+            scope,
+            "type_annotation",
+            TsDefiniteVariableAnnotation_type_annotation,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsEmptyExternalModuleDeclarationBody>(
+            scope,
+            global,
+            "TsEmptyExternalModuleDeclarationBody",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "semicolon_token",
+            TsEmptyExternalModuleDeclarationBody_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsEnumDeclaration>(scope, global, "TsEnumDeclaration")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "const_token", TsEnumDeclaration_const_token)
+        .method(scope, "enum_token", TsEnumDeclaration_enum_token)
+        .method(scope, "id", TsEnumDeclaration_id)
+        .method(scope, "l_curly_token", TsEnumDeclaration_l_curly_token)
+        .method(scope, "members", TsEnumDeclaration_members)
+        .method(scope, "r_curly_token", TsEnumDeclaration_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsEnumMember>(scope, global, "TsEnumMember")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "name", TsEnumMember_name)
+        .method(scope, "initializer", TsEnumMember_initializer)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsExportAsNamespaceClause>(
+            scope,
+            global,
+            "TsExportAsNamespaceClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "as_token", TsExportAsNamespaceClause_as_token)
+        .method(
+            scope,
+            "namespace_token",
+            TsExportAsNamespaceClause_namespace_token,
+        )
+        .method(scope, "name", TsExportAsNamespaceClause_name)
+        .method(
+            scope,
+            "semicolon_token",
+            TsExportAsNamespaceClause_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsExportAssignmentClause>(
+            scope,
+            global,
+            "TsExportAssignmentClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "eq_token", TsExportAssignmentClause_eq_token)
+        .method(scope, "expression", TsExportAssignmentClause_expression)
+        .method(
+            scope,
+            "semicolon_token",
+            TsExportAssignmentClause_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsExportDeclareClause>(
+            scope,
+            global,
+            "TsExportDeclareClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "declare_token", TsExportDeclareClause_declare_token)
+        .method(scope, "declaration", TsExportDeclareClause_declaration)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsExtendsClause>(scope, global, "TsExtendsClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "extends_token", TsExtendsClause_extends_token)
+        .method(scope, "types", TsExtendsClause_types)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsExternalModuleDeclaration>(
+            scope,
+            global,
+            "TsExternalModuleDeclaration",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "module_token",
+            TsExternalModuleDeclaration_module_token,
+        )
+        .method(scope, "source", TsExternalModuleDeclaration_source)
+        .method(scope, "body", TsExternalModuleDeclaration_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsExternalModuleReference>(
+            scope,
+            global,
+            "TsExternalModuleReference",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "require_token",
+            TsExternalModuleReference_require_token,
+        )
+        .method(
+            scope,
+            "l_paren_token",
+            TsExternalModuleReference_l_paren_token,
+        )
+        .method(scope, "source", TsExternalModuleReference_source)
+        .method(
+            scope,
+            "r_paren_token",
+            TsExternalModuleReference_r_paren_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsFunctionType>(scope, global, "TsFunctionType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "type_parameters", TsFunctionType_type_parameters)
+        .method(scope, "parameters", TsFunctionType_parameters)
+        .method(scope, "fat_arrow_token", TsFunctionType_fat_arrow_token)
+        .method(scope, "return_type", TsFunctionType_return_type)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsGetterSignatureClassMember>(
+            scope,
+            global,
+            "TsGetterSignatureClassMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifiers", TsGetterSignatureClassMember_modifiers)
+        .method(scope, "get_token", TsGetterSignatureClassMember_get_token)
+        .method(scope, "name", TsGetterSignatureClassMember_name)
+        .method(
+            scope,
+            "l_paren_token",
+            TsGetterSignatureClassMember_l_paren_token,
+        )
+        .method(
+            scope,
+            "r_paren_token",
+            TsGetterSignatureClassMember_r_paren_token,
+        )
+        .method(
+            scope,
+            "return_type",
+            TsGetterSignatureClassMember_return_type,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            TsGetterSignatureClassMember_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsGetterSignatureTypeMember>(
+            scope,
+            global,
+            "TsGetterSignatureTypeMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "get_token", TsGetterSignatureTypeMember_get_token)
+        .method(scope, "name", TsGetterSignatureTypeMember_name)
+        .method(
+            scope,
+            "l_paren_token",
+            TsGetterSignatureTypeMember_l_paren_token,
+        )
+        .method(
+            scope,
+            "r_paren_token",
+            TsGetterSignatureTypeMember_r_paren_token,
+        )
+        .method(
+            scope,
+            "type_annotation",
+            TsGetterSignatureTypeMember_type_annotation,
+        )
+        .method(
+            scope,
+            "separator_token",
+            TsGetterSignatureTypeMember_separator_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsGlobalDeclaration>(scope, global, "TsGlobalDeclaration")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "global_token", TsGlobalDeclaration_global_token)
+        .method(scope, "body", TsGlobalDeclaration_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsIdentifierBinding>(scope, global, "TsIdentifierBinding")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "name_token", TsIdentifierBinding_name_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsImplementsClause>(scope, global, "TsImplementsClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "implements_token",
+            TsImplementsClause_implements_token,
+        )
+        .method(scope, "types", TsImplementsClause_types)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsImportEqualsDeclaration>(
+            scope,
+            global,
+            "TsImportEqualsDeclaration",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "import_token",
+            TsImportEqualsDeclaration_import_token,
+        )
+        .method(scope, "type_token", TsImportEqualsDeclaration_type_token)
+        .method(scope, "id", TsImportEqualsDeclaration_id)
+        .method(scope, "eq_token", TsImportEqualsDeclaration_eq_token)
+        .method(
+            scope,
+            "module_reference",
+            TsImportEqualsDeclaration_module_reference,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            TsImportEqualsDeclaration_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsImportType>(scope, global, "TsImportType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "typeof_token", TsImportType_typeof_token)
+        .method(scope, "import_token", TsImportType_import_token)
+        .method(scope, "l_paren_token", TsImportType_l_paren_token)
+        .method(scope, "argument_token", TsImportType_argument_token)
+        .method(scope, "r_paren_token", TsImportType_r_paren_token)
+        .method(scope, "qualifier_clause", TsImportType_qualifier_clause)
+        .method(scope, "type_arguments", TsImportType_type_arguments)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsImportTypeQualifier>(
+            scope,
+            global,
+            "TsImportTypeQualifier",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "dot_token", TsImportTypeQualifier_dot_token)
+        .method(scope, "right", TsImportTypeQualifier_right)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsInModifier>(scope, global, "TsInModifier")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifier_token", TsInModifier_modifier_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsIndexSignatureClassMember>(
+            scope,
+            global,
+            "TsIndexSignatureClassMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifiers", TsIndexSignatureClassMember_modifiers)
+        .method(
+            scope,
+            "l_brack_token",
+            TsIndexSignatureClassMember_l_brack_token,
+        )
+        .method(scope, "parameter", TsIndexSignatureClassMember_parameter)
+        .method(
+            scope,
+            "r_brack_token",
+            TsIndexSignatureClassMember_r_brack_token,
+        )
+        .method(
+            scope,
+            "type_annotation",
+            TsIndexSignatureClassMember_type_annotation,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            TsIndexSignatureClassMember_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsIndexSignatureParameter>(
+            scope,
+            global,
+            "TsIndexSignatureParameter",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "binding", TsIndexSignatureParameter_binding)
+        .method(
+            scope,
+            "type_annotation",
+            TsIndexSignatureParameter_type_annotation,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsIndexSignatureTypeMember>(
+            scope,
+            global,
+            "TsIndexSignatureTypeMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "readonly_token",
+            TsIndexSignatureTypeMember_readonly_token,
+        )
+        .method(
+            scope,
+            "l_brack_token",
+            TsIndexSignatureTypeMember_l_brack_token,
+        )
+        .method(scope, "parameter", TsIndexSignatureTypeMember_parameter)
+        .method(
+            scope,
+            "r_brack_token",
+            TsIndexSignatureTypeMember_r_brack_token,
+        )
+        .method(
+            scope,
+            "type_annotation",
+            TsIndexSignatureTypeMember_type_annotation,
+        )
+        .method(
+            scope,
+            "separator_token",
+            TsIndexSignatureTypeMember_separator_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsIndexedAccessType>(scope, global, "TsIndexedAccessType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "object_type", TsIndexedAccessType_object_type)
+        .method(scope, "l_brack_token", TsIndexedAccessType_l_brack_token)
+        .method(scope, "index_type", TsIndexedAccessType_index_type)
+        .method(scope, "r_brack_token", TsIndexedAccessType_r_brack_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsInferType>(scope, global, "TsInferType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "infer_token", TsInferType_infer_token)
+        .method(scope, "name", TsInferType_name)
+        .method(scope, "constraint", TsInferType_constraint)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsInitializedPropertySignatureClassMember>(
+            scope,
+            global,
+            "TsInitializedPropertySignatureClassMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "modifiers",
+            TsInitializedPropertySignatureClassMember_modifiers,
+        )
+        .method(
+            scope,
+            "name",
+            TsInitializedPropertySignatureClassMember_name,
+        )
+        .method(
+            scope,
+            "question_mark_token",
+            TsInitializedPropertySignatureClassMember_question_mark_token,
+        )
+        .method(
+            scope,
+            "value",
+            TsInitializedPropertySignatureClassMember_value,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            TsInitializedPropertySignatureClassMember_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsInstantiationExpression>(
+            scope,
+            global,
+            "TsInstantiationExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "expression", TsInstantiationExpression_expression)
+        .method(scope, "arguments", TsInstantiationExpression_arguments)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsInterfaceDeclaration>(
+            scope,
+            global,
+            "TsInterfaceDeclaration",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "interface_token",
+            TsInterfaceDeclaration_interface_token,
+        )
+        .method(scope, "id", TsInterfaceDeclaration_id)
+        .method(
+            scope,
+            "type_parameters",
+            TsInterfaceDeclaration_type_parameters,
+        )
+        .method(
+            scope,
+            "extends_clause",
+            TsInterfaceDeclaration_extends_clause,
+        )
+        .method(scope, "l_curly_token", TsInterfaceDeclaration_l_curly_token)
+        .method(scope, "members", TsInterfaceDeclaration_members)
+        .method(scope, "r_curly_token", TsInterfaceDeclaration_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsIntersectionType>(scope, global, "TsIntersectionType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "leading_separator_token",
+            TsIntersectionType_leading_separator_token,
+        )
+        .method(scope, "types", TsIntersectionType_types)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsMappedType>(scope, global, "TsMappedType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_curly_token", TsMappedType_l_curly_token)
+        .method(scope, "readonly_modifier", TsMappedType_readonly_modifier)
+        .method(scope, "l_brack_token", TsMappedType_l_brack_token)
+        .method(scope, "property_name", TsMappedType_property_name)
+        .method(scope, "in_token", TsMappedType_in_token)
+        .method(scope, "keys_type", TsMappedType_keys_type)
+        .method(scope, "as_clause", TsMappedType_as_clause)
+        .method(scope, "r_brack_token", TsMappedType_r_brack_token)
+        .method(scope, "optional_modifier", TsMappedType_optional_modifier)
+        .method(scope, "mapped_type", TsMappedType_mapped_type)
+        .method(scope, "semicolon_token", TsMappedType_semicolon_token)
+        .method(scope, "r_curly_token", TsMappedType_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsMappedTypeAsClause>(scope, global, "TsMappedTypeAsClause")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "as_token", TsMappedTypeAsClause_as_token)
+        .method(scope, "ty", TsMappedTypeAsClause_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsMappedTypeOptionalModifierClause>(
+            scope,
+            global,
+            "TsMappedTypeOptionalModifierClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "operator_token",
+            TsMappedTypeOptionalModifierClause_operator_token,
+        )
+        .method(
+            scope,
+            "question_mark_token",
+            TsMappedTypeOptionalModifierClause_question_mark_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsMappedTypeReadonlyModifierClause>(
+            scope,
+            global,
+            "TsMappedTypeReadonlyModifierClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "operator_token",
+            TsMappedTypeReadonlyModifierClause_operator_token,
+        )
+        .method(
+            scope,
+            "readonly_token",
+            TsMappedTypeReadonlyModifierClause_readonly_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsMethodSignatureClassMember>(
+            scope,
+            global,
+            "TsMethodSignatureClassMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifiers", TsMethodSignatureClassMember_modifiers)
+        .method(
+            scope,
+            "async_token",
+            TsMethodSignatureClassMember_async_token,
+        )
+        .method(scope, "name", TsMethodSignatureClassMember_name)
+        .method(
+            scope,
+            "question_mark_token",
+            TsMethodSignatureClassMember_question_mark_token,
+        )
+        .method(
+            scope,
+            "type_parameters",
+            TsMethodSignatureClassMember_type_parameters,
+        )
+        .method(scope, "parameters", TsMethodSignatureClassMember_parameters)
+        .method(
+            scope,
+            "return_type_annotation",
+            TsMethodSignatureClassMember_return_type_annotation,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            TsMethodSignatureClassMember_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsMethodSignatureTypeMember>(
+            scope,
+            global,
+            "TsMethodSignatureTypeMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "name", TsMethodSignatureTypeMember_name)
+        .method(
+            scope,
+            "optional_token",
+            TsMethodSignatureTypeMember_optional_token,
+        )
+        .method(
+            scope,
+            "type_parameters",
+            TsMethodSignatureTypeMember_type_parameters,
+        )
+        .method(scope, "parameters", TsMethodSignatureTypeMember_parameters)
+        .method(
+            scope,
+            "return_type_annotation",
+            TsMethodSignatureTypeMember_return_type_annotation,
+        )
+        .method(
+            scope,
+            "separator_token",
+            TsMethodSignatureTypeMember_separator_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsModuleBlock>(scope, global, "TsModuleBlock")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_curly_token", TsModuleBlock_l_curly_token)
+        .method(scope, "items", TsModuleBlock_items)
+        .method(scope, "r_curly_token", TsModuleBlock_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsModuleDeclaration>(scope, global, "TsModuleDeclaration")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "module_or_namespace",
+            TsModuleDeclaration_module_or_namespace,
+        )
+        .method(scope, "name", TsModuleDeclaration_name)
+        .method(scope, "body", TsModuleDeclaration_body)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsNameWithTypeArguments>(
+            scope,
+            global,
+            "TsNameWithTypeArguments",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "name", TsNameWithTypeArguments_name)
+        .method(
+            scope,
+            "type_arguments",
+            TsNameWithTypeArguments_type_arguments,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsNamedTupleTypeElement>(
+            scope,
+            global,
+            "TsNamedTupleTypeElement",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "dotdotdot_token",
+            TsNamedTupleTypeElement_dotdotdot_token,
+        )
+        .method(scope, "name", TsNamedTupleTypeElement_name)
+        .method(
+            scope,
+            "question_mark_token",
+            TsNamedTupleTypeElement_question_mark_token,
+        )
+        .method(scope, "colon_token", TsNamedTupleTypeElement_colon_token)
+        .method(scope, "ty", TsNamedTupleTypeElement_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsNeverType>(scope, global, "TsNeverType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "never_token", TsNeverType_never_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsNonNullAssertionAssignment>(
+            scope,
+            global,
+            "TsNonNullAssertionAssignment",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "assignment", TsNonNullAssertionAssignment_assignment)
+        .method(scope, "excl_token", TsNonNullAssertionAssignment_excl_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsNonNullAssertionExpression>(
+            scope,
+            global,
+            "TsNonNullAssertionExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "expression", TsNonNullAssertionExpression_expression)
+        .method(scope, "excl_token", TsNonNullAssertionExpression_excl_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsNonPrimitiveType>(scope, global, "TsNonPrimitiveType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "object_token", TsNonPrimitiveType_object_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsNullLiteralType>(scope, global, "TsNullLiteralType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "literal_token", TsNullLiteralType_literal_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsNumberLiteralType>(scope, global, "TsNumberLiteralType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "minus_token", TsNumberLiteralType_minus_token)
+        .method(scope, "literal_token", TsNumberLiteralType_literal_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsNumberType>(scope, global, "TsNumberType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "number_token", TsNumberType_number_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsObjectType>(scope, global, "TsObjectType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_curly_token", TsObjectType_l_curly_token)
+        .method(scope, "members", TsObjectType_members)
+        .method(scope, "r_curly_token", TsObjectType_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsOptionalPropertyAnnotation>(
+            scope,
+            global,
+            "TsOptionalPropertyAnnotation",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "question_mark_token",
+            TsOptionalPropertyAnnotation_question_mark_token,
+        )
+        .method(
+            scope,
+            "type_annotation",
+            TsOptionalPropertyAnnotation_type_annotation,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsOptionalTupleTypeElement>(
+            scope,
+            global,
+            "TsOptionalTupleTypeElement",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "ty", TsOptionalTupleTypeElement_ty)
+        .method(
+            scope,
+            "question_mark_token",
+            TsOptionalTupleTypeElement_question_mark_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsOutModifier>(scope, global, "TsOutModifier")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifier_token", TsOutModifier_modifier_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsOverrideModifier>(scope, global, "TsOverrideModifier")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifier_token", TsOverrideModifier_modifier_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsParenthesizedType>(scope, global, "TsParenthesizedType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_paren_token", TsParenthesizedType_l_paren_token)
+        .method(scope, "ty", TsParenthesizedType_ty)
+        .method(scope, "r_paren_token", TsParenthesizedType_r_paren_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsPredicateReturnType>(
+            scope,
+            global,
+            "TsPredicateReturnType",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "parameter_name",
+            TsPredicateReturnType_parameter_name,
+        )
+        .method(scope, "is_token", TsPredicateReturnType_is_token)
+        .method(scope, "ty", TsPredicateReturnType_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsPropertyParameter>(scope, global, "TsPropertyParameter")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "decorators", TsPropertyParameter_decorators)
+        .method(scope, "modifiers", TsPropertyParameter_modifiers)
+        .method(
+            scope,
+            "formal_parameter",
+            TsPropertyParameter_formal_parameter,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsPropertySignatureClassMember>(
+            scope,
+            global,
+            "TsPropertySignatureClassMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifiers", TsPropertySignatureClassMember_modifiers)
+        .method(scope, "name", TsPropertySignatureClassMember_name)
+        .method(
+            scope,
+            "property_annotation",
+            TsPropertySignatureClassMember_property_annotation,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            TsPropertySignatureClassMember_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsPropertySignatureTypeMember>(
+            scope,
+            global,
+            "TsPropertySignatureTypeMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "readonly_token",
+            TsPropertySignatureTypeMember_readonly_token,
+        )
+        .method(scope, "name", TsPropertySignatureTypeMember_name)
+        .method(
+            scope,
+            "optional_token",
+            TsPropertySignatureTypeMember_optional_token,
+        )
+        .method(
+            scope,
+            "type_annotation",
+            TsPropertySignatureTypeMember_type_annotation,
+        )
+        .method(
+            scope,
+            "separator_token",
+            TsPropertySignatureTypeMember_separator_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsQualifiedModuleName>(
+            scope,
+            global,
+            "TsQualifiedModuleName",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "left", TsQualifiedModuleName_left)
+        .method(scope, "dot_token", TsQualifiedModuleName_dot_token)
+        .method(scope, "right", TsQualifiedModuleName_right)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsQualifiedName>(scope, global, "TsQualifiedName")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "left", TsQualifiedName_left)
+        .method(scope, "dot_token", TsQualifiedName_dot_token)
+        .method(scope, "right", TsQualifiedName_right)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsReadonlyModifier>(scope, global, "TsReadonlyModifier")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifier_token", TsReadonlyModifier_modifier_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsReferenceType>(scope, global, "TsReferenceType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "name", TsReferenceType_name)
+        .method(scope, "type_arguments", TsReferenceType_type_arguments)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsRestTupleTypeElement>(
+            scope,
+            global,
+            "TsRestTupleTypeElement",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "dotdotdot_token",
+            TsRestTupleTypeElement_dotdotdot_token,
+        )
+        .method(scope, "ty", TsRestTupleTypeElement_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsReturnTypeAnnotation>(
+            scope,
+            global,
+            "TsReturnTypeAnnotation",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "colon_token", TsReturnTypeAnnotation_colon_token)
+        .method(scope, "ty", TsReturnTypeAnnotation_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsSatisfiesAssignment>(
+            scope,
+            global,
+            "TsSatisfiesAssignment",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "assignment", TsSatisfiesAssignment_assignment)
+        .method(
+            scope,
+            "satisfies_token",
+            TsSatisfiesAssignment_satisfies_token,
+        )
+        .method(scope, "ty", TsSatisfiesAssignment_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsSatisfiesExpression>(
+            scope,
+            global,
+            "TsSatisfiesExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "expression", TsSatisfiesExpression_expression)
+        .method(
+            scope,
+            "satisfies_token",
+            TsSatisfiesExpression_satisfies_token,
+        )
+        .method(scope, "ty", TsSatisfiesExpression_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsSetterSignatureClassMember>(
+            scope,
+            global,
+            "TsSetterSignatureClassMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifiers", TsSetterSignatureClassMember_modifiers)
+        .method(scope, "set_token", TsSetterSignatureClassMember_set_token)
+        .method(scope, "name", TsSetterSignatureClassMember_name)
+        .method(
+            scope,
+            "l_paren_token",
+            TsSetterSignatureClassMember_l_paren_token,
+        )
+        .method(scope, "parameter", TsSetterSignatureClassMember_parameter)
+        .method(
+            scope,
+            "r_paren_token",
+            TsSetterSignatureClassMember_r_paren_token,
+        )
+        .method(
+            scope,
+            "semicolon_token",
+            TsSetterSignatureClassMember_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsSetterSignatureTypeMember>(
+            scope,
+            global,
+            "TsSetterSignatureTypeMember",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "set_token", TsSetterSignatureTypeMember_set_token)
+        .method(scope, "name", TsSetterSignatureTypeMember_name)
+        .method(
+            scope,
+            "l_paren_token",
+            TsSetterSignatureTypeMember_l_paren_token,
+        )
+        .method(scope, "parameter", TsSetterSignatureTypeMember_parameter)
+        .method(
+            scope,
+            "r_paren_token",
+            TsSetterSignatureTypeMember_r_paren_token,
+        )
+        .method(
+            scope,
+            "separator_token",
+            TsSetterSignatureTypeMember_separator_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsStringLiteralType>(scope, global, "TsStringLiteralType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "literal_token", TsStringLiteralType_literal_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsStringType>(scope, global, "TsStringType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "string_token", TsStringType_string_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsSymbolType>(scope, global, "TsSymbolType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "symbol_token", TsSymbolType_symbol_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTemplateChunkElement>(
+            scope,
+            global,
+            "TsTemplateChunkElement",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "template_chunk_token",
+            TsTemplateChunkElement_template_chunk_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTemplateElement>(scope, global, "TsTemplateElement")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "dollar_curly_token",
+            TsTemplateElement_dollar_curly_token,
+        )
+        .method(scope, "ty", TsTemplateElement_ty)
+        .method(scope, "r_curly_token", TsTemplateElement_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTemplateLiteralType>(
+            scope,
+            global,
+            "TsTemplateLiteralType",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_tick_token", TsTemplateLiteralType_l_tick_token)
+        .method(scope, "elements", TsTemplateLiteralType_elements)
+        .method(scope, "r_tick_token", TsTemplateLiteralType_r_tick_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsThisParameter>(scope, global, "TsThisParameter")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "this_token", TsThisParameter_this_token)
+        .method(scope, "type_annotation", TsThisParameter_type_annotation)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsThisType>(scope, global, "TsThisType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "this_token", TsThisType_this_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTupleType>(scope, global, "TsTupleType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_brack_token", TsTupleType_l_brack_token)
+        .method(scope, "elements", TsTupleType_elements)
+        .method(scope, "r_brack_token", TsTupleType_r_brack_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeAliasDeclaration>(
+            scope,
+            global,
+            "TsTypeAliasDeclaration",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "type_token", TsTypeAliasDeclaration_type_token)
+        .method(
+            scope,
+            "binding_identifier",
+            TsTypeAliasDeclaration_binding_identifier,
+        )
+        .method(
+            scope,
+            "type_parameters",
+            TsTypeAliasDeclaration_type_parameters,
+        )
+        .method(scope, "eq_token", TsTypeAliasDeclaration_eq_token)
+        .method(scope, "ty", TsTypeAliasDeclaration_ty)
+        .method(
+            scope,
+            "semicolon_token",
+            TsTypeAliasDeclaration_semicolon_token,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeAnnotation>(scope, global, "TsTypeAnnotation")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "colon_token", TsTypeAnnotation_colon_token)
+        .method(scope, "ty", TsTypeAnnotation_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeArguments>(scope, global, "TsTypeArguments")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_angle_token", TsTypeArguments_l_angle_token)
+        .method(
+            scope,
+            "ts_type_argument_list",
+            TsTypeArguments_ts_type_argument_list,
+        )
+        .method(scope, "r_angle_token", TsTypeArguments_r_angle_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeAssertionAssignment>(
+            scope,
+            global,
+            "TsTypeAssertionAssignment",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "l_angle_token",
+            TsTypeAssertionAssignment_l_angle_token,
+        )
+        .method(scope, "ty", TsTypeAssertionAssignment_ty)
+        .method(
+            scope,
+            "r_angle_token",
+            TsTypeAssertionAssignment_r_angle_token,
+        )
+        .method(scope, "assignment", TsTypeAssertionAssignment_assignment)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeAssertionExpression>(
+            scope,
+            global,
+            "TsTypeAssertionExpression",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "l_angle_token",
+            TsTypeAssertionExpression_l_angle_token,
+        )
+        .method(scope, "ty", TsTypeAssertionExpression_ty)
+        .method(
+            scope,
+            "r_angle_token",
+            TsTypeAssertionExpression_r_angle_token,
+        )
+        .method(scope, "expression", TsTypeAssertionExpression_expression)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeConstraintClause>(
+            scope,
+            global,
+            "TsTypeConstraintClause",
+        )
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "extends_token", TsTypeConstraintClause_extends_token)
+        .method(scope, "ty", TsTypeConstraintClause_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeOperatorType>(scope, global, "TsTypeOperatorType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "operator_token", TsTypeOperatorType_operator_token)
+        .method(scope, "ty", TsTypeOperatorType_ty)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeParameter>(scope, global, "TsTypeParameter")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "modifiers", TsTypeParameter_modifiers)
+        .method(scope, "name", TsTypeParameter_name)
+        .method(scope, "constraint", TsTypeParameter_constraint)
+        .method(scope, "default", TsTypeParameter_default)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeParameterName>(scope, global, "TsTypeParameterName")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "ident_token", TsTypeParameterName_ident_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeParameters>(scope, global, "TsTypeParameters")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "l_angle_token", TsTypeParameters_l_angle_token)
+        .method(scope, "items", TsTypeParameters_items)
+        .method(scope, "r_angle_token", TsTypeParameters_r_angle_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeofType>(scope, global, "TsTypeofType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "typeof_token", TsTypeofType_typeof_token)
+        .method(scope, "expression_name", TsTypeofType_expression_name)
+        .method(scope, "type_arguments", TsTypeofType_type_arguments)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsUndefinedType>(scope, global, "TsUndefinedType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "undefined_token", TsUndefinedType_undefined_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsUnionType>(scope, global, "TsUnionType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(
+            scope,
+            "leading_separator_token",
+            TsUnionType_leading_separator_token,
+        )
+        .method(scope, "types", TsUnionType_types)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsUnknownType>(scope, global, "TsUnknownType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "unknown_token", TsUnknownType_unknown_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsVoidType>(scope, global, "TsVoidType")
+        .extends::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>(scope)
+        .method(scope, "void_token", TsVoidType_void_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBogus>(scope, global, "JsBogus")
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBogusAssignment>(scope, global, "JsBogusAssignment")
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBogusBinding>(scope, global, "JsBogusBinding")
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBogusExpression>(scope, global, "JsBogusExpression")
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBogusImportAssertionEntry>(
+            scope,
+            global,
+            "JsBogusImportAssertionEntry",
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBogusMember>(scope, global, "JsBogusMember")
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBogusNamedImportSpecifier>(
+            scope,
+            global,
+            "JsBogusNamedImportSpecifier",
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBogusParameter>(scope, global, "JsBogusParameter")
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsBogusStatement>(scope, global, "JsBogusStatement")
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsBogusType>(scope, global, "TsBogusType")
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsArrayAssignmentPatternElementList>(
+            scope,
+            global,
+            "JsArrayAssignmentPatternElementList",
+        )
+        .method(scope, "iter", JsArrayAssignmentPatternElementList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsArrayBindingPatternElementList>(
+            scope,
+            global,
+            "JsArrayBindingPatternElementList",
+        )
+        .method(scope, "iter", JsArrayBindingPatternElementList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsArrayElementList>(scope, global, "JsArrayElementList")
+        .method(scope, "iter", JsArrayElementList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsCallArgumentList>(scope, global, "JsCallArgumentList")
+        .method(scope, "iter", JsCallArgumentList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsClassMemberList>(scope, global, "JsClassMemberList")
+        .method(scope, "iter", JsClassMemberList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsConstructorModifierList>(
+            scope,
+            global,
+            "JsConstructorModifierList",
+        )
+        .method(scope, "iter", JsConstructorModifierList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsConstructorParameterList>(
+            scope,
+            global,
+            "JsConstructorParameterList",
+        )
+        .method(scope, "iter", JsConstructorParameterList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsDecoratorList>(scope, global, "JsDecoratorList")
+        .method(scope, "iter", JsDecoratorList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsDirectiveList>(scope, global, "JsDirectiveList")
+        .method(scope, "iter", JsDirectiveList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExportNamedFromSpecifierList>(
+            scope,
+            global,
+            "JsExportNamedFromSpecifierList",
+        )
+        .method(scope, "iter", JsExportNamedFromSpecifierList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsExportNamedSpecifierList>(
+            scope,
+            global,
+            "JsExportNamedSpecifierList",
+        )
+        .method(scope, "iter", JsExportNamedSpecifierList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsImportAssertionEntryList>(
+            scope,
+            global,
+            "JsImportAssertionEntryList",
+        )
+        .method(scope, "iter", JsImportAssertionEntryList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsMethodModifierList>(scope, global, "JsMethodModifierList")
+        .method(scope, "iter", JsMethodModifierList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsModuleItemList>(scope, global, "JsModuleItemList")
+        .method(scope, "iter", JsModuleItemList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsNamedImportSpecifierList>(
+            scope,
+            global,
+            "JsNamedImportSpecifierList",
+        )
+        .method(scope, "iter", JsNamedImportSpecifierList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsObjectAssignmentPatternPropertyList>(
+            scope,
+            global,
+            "JsObjectAssignmentPatternPropertyList",
+        )
+        .method(scope, "iter", JsObjectAssignmentPatternPropertyList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsObjectBindingPatternPropertyList>(
+            scope,
+            global,
+            "JsObjectBindingPatternPropertyList",
+        )
+        .method(scope, "iter", JsObjectBindingPatternPropertyList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsObjectMemberList>(scope, global, "JsObjectMemberList")
+        .method(scope, "iter", JsObjectMemberList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsParameterList>(scope, global, "JsParameterList")
+        .method(scope, "iter", JsParameterList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsPropertyModifierList>(
+            scope,
+            global,
+            "JsPropertyModifierList",
+        )
+        .method(scope, "iter", JsPropertyModifierList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsStatementList>(scope, global, "JsStatementList")
+        .method(scope, "iter", JsStatementList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsSwitchCaseList>(scope, global, "JsSwitchCaseList")
+        .method(scope, "iter", JsSwitchCaseList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsTemplateElementList>(
+            scope,
+            global,
+            "JsTemplateElementList",
+        )
+        .method(scope, "iter", JsTemplateElementList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsVariableDeclaratorList>(
+            scope,
+            global,
+            "JsVariableDeclaratorList",
+        )
+        .method(scope, "iter", JsVariableDeclaratorList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxAttributeList>(scope, global, "JsxAttributeList")
+        .method(scope, "iter", JsxAttributeList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsxChildList>(scope, global, "JsxChildList")
+        .method(scope, "iter", JsxChildList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsEnumMemberList>(scope, global, "TsEnumMemberList")
+        .method(scope, "iter", TsEnumMemberList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsIndexSignatureModifierList>(
+            scope,
+            global,
+            "TsIndexSignatureModifierList",
+        )
+        .method(scope, "iter", TsIndexSignatureModifierList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsIntersectionTypeElementList>(
+            scope,
+            global,
+            "TsIntersectionTypeElementList",
+        )
+        .method(scope, "iter", TsIntersectionTypeElementList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsMethodSignatureModifierList>(
+            scope,
+            global,
+            "TsMethodSignatureModifierList",
+        )
+        .method(scope, "iter", TsMethodSignatureModifierList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsPropertyParameterModifierList>(
+            scope,
+            global,
+            "TsPropertyParameterModifierList",
+        )
+        .method(scope, "iter", TsPropertyParameterModifierList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsPropertySignatureModifierList>(
+            scope,
+            global,
+            "TsPropertySignatureModifierList",
+        )
+        .method(scope, "iter", TsPropertySignatureModifierList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTemplateElementList>(
+            scope,
+            global,
+            "TsTemplateElementList",
+        )
+        .method(scope, "iter", TsTemplateElementList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTupleTypeElementList>(
+            scope,
+            global,
+            "TsTupleTypeElementList",
+        )
+        .method(scope, "iter", TsTupleTypeElementList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeArgumentList>(scope, global, "TsTypeArgumentList")
+        .method(scope, "iter", TsTypeArgumentList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeList>(scope, global, "TsTypeList")
+        .method(scope, "iter", TsTypeList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeMemberList>(scope, global, "TsTypeMemberList")
+        .method(scope, "iter", TsTypeMemberList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeParameterList>(scope, global, "TsTypeParameterList")
+        .method(scope, "iter", TsTypeParameterList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsTypeParameterModifierList>(
+            scope,
+            global,
+            "TsTypeParameterModifierList",
+        )
+        .method(scope, "iter", TsTypeParameterModifierList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::TsUnionTypeVariantList>(
+            scope,
+            global,
+            "TsUnionTypeVariantList",
+        )
+        .method(scope, "iter", TsUnionTypeVariantList_iter)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsArrayAssignmentPatternElement,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsArrayBindingPatternElement,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsArrayElement,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsCallArgument,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsClassMember,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsConstructorParameter,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsExportNamedSpecifier,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsImportAssertionEntry,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsMethodModifier,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry . build_interface :: < rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsModuleItem > > (scope) . iterable (scope , ToV8 :: to_v8) . finish (scope) ;
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsNamedImportSpecifier,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsObjectAssignmentPatternMember,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsObjectBindingPatternMember,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsObjectMember,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsParameter,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsPropertyModifier,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry . build_interface :: < rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsStatement > > (scope) . iterable (scope , ToV8 :: to_v8) . finish (scope) ;
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsSwitchClause,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyJsTemplateElement,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry . build_interface :: < rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsxAttribute > > (scope) . iterable (scope , ToV8 :: to_v8) . finish (scope) ;
+    registry . build_interface :: < rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsxChild > > (scope) . iterable (scope , ToV8 :: to_v8) . finish (scope) ;
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyTsIndexSignatureModifier,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyTsMethodSignatureModifier,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyTsPropertyParameterModifier,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyTsPropertySignatureModifier,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyTsTemplateElement,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyTsTupleTypeElement,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyTsType,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry . build_interface :: < rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyTsTypeMember > > (scope) . iterable (scope , ToV8 :: to_v8) . finish (scope) ;
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::AnyTsTypeParameterModifier,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry . build_interface :: < rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: JsDecorator > > (scope) . iterable (scope , ToV8 :: to_v8) . finish (scope) ;
+    registry . build_interface :: < rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: JsDirective > > (scope) . iterable (scope , ToV8 :: to_v8) . finish (scope) ;
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::JsExportNamedFromSpecifier,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::JsVariableDeclarator,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstNodeListIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::TsAccessibilityModifier,
+        >>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::TsEnumMember,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::TsNameWithTypeArguments,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_js_syntax::JsLanguage,
+            rome_js_syntax::TsTypeParameter,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+}
+#[allow(non_snake_case)]
+fn AstSeparatedListNodesIterator_next<'s, T: ToV8<'s>>(
+    item: rome_rowan::SyntaxResult<T>,
+    scope: &mut v8::HandleScope<'s>,
+) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+    ToV8::to_v8(item?, scope)
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsAccessorModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsAccessorModifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsAccessorModifier_modifier_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsAccessorModifier::cast_ref(&*this).unwrap();
+    let result = this.modifier_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsArrayAssignmentPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsArrayAssignmentPattern,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrayAssignmentPattern_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayAssignmentPattern::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrayAssignmentPattern_elements<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayAssignmentPattern::cast_ref(&*this).unwrap();
+    let result = this.elements();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsArrayAssignmentPattern_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayAssignmentPattern::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsArrayAssignmentPatternRestElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsArrayAssignmentPatternRestElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrayAssignmentPatternRestElement_dotdotdot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayAssignmentPatternRestElement::cast_ref(&*this).unwrap();
+    let result = this.dotdotdot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrayAssignmentPatternRestElement_pattern<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayAssignmentPatternRestElement::cast_ref(&*this).unwrap();
+    let result = this.pattern();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsArrayBindingPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsArrayBindingPattern,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrayBindingPattern_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayBindingPattern::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrayBindingPattern_elements<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayBindingPattern::cast_ref(&*this).unwrap();
+    let result = this.elements();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsArrayBindingPattern_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayBindingPattern::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsArrayBindingPatternRestElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsArrayBindingPatternRestElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrayBindingPatternRestElement_dotdotdot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayBindingPatternRestElement::cast_ref(&*this).unwrap();
+    let result = this.dotdotdot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrayBindingPatternRestElement_pattern<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayBindingPatternRestElement::cast_ref(&*this).unwrap();
+    let result = this.pattern();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsArrayExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsArrayExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrayExpression_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayExpression::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrayExpression_elements<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayExpression::cast_ref(&*this).unwrap();
+    let result = this.elements();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsArrayExpression_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrayExpression::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsArrayHole {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsArrayHole,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsArrowFunctionExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsArrowFunctionExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrowFunctionExpression_async_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrowFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.async_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrowFunctionExpression_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrowFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrowFunctionExpression_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrowFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrowFunctionExpression_return_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrowFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.return_type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrowFunctionExpression_fat_arrow_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrowFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.fat_arrow_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsArrowFunctionExpression_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsArrowFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsAssignmentExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsAssignmentExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsAssignmentExpression_left<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsAssignmentExpression::cast_ref(&*this).unwrap();
+    let result = this.left();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsAssignmentExpression_operator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsAssignmentExpression::cast_ref(&*this).unwrap();
+    let result = this.operator_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsAssignmentExpression_right<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsAssignmentExpression::cast_ref(&*this).unwrap();
+    let result = this.right();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsAssignmentWithDefault {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsAssignmentWithDefault,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsAssignmentWithDefault_pattern<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsAssignmentWithDefault::cast_ref(&*this).unwrap();
+    let result = this.pattern();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsAssignmentWithDefault_eq_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsAssignmentWithDefault::cast_ref(&*this).unwrap();
+    let result = this.eq_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsAssignmentWithDefault_default<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsAssignmentWithDefault::cast_ref(&*this).unwrap();
+    let result = this.default();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsAwaitExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsAwaitExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsAwaitExpression_await_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsAwaitExpression::cast_ref(&*this).unwrap();
+    let result = this.await_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsAwaitExpression_argument<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsAwaitExpression::cast_ref(&*this).unwrap();
+    let result = this.argument();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsBigintLiteralExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsBigintLiteralExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsBigintLiteralExpression_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBigintLiteralExpression::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsBinaryExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsBinaryExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsBinaryExpression_left<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBinaryExpression::cast_ref(&*this).unwrap();
+    let result = this.left();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsBinaryExpression_operator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBinaryExpression::cast_ref(&*this).unwrap();
+    let result = this.operator_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsBinaryExpression_right<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBinaryExpression::cast_ref(&*this).unwrap();
+    let result = this.right();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsBindingPatternWithDefault {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsBindingPatternWithDefault,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsBindingPatternWithDefault_pattern<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBindingPatternWithDefault::cast_ref(&*this).unwrap();
+    let result = this.pattern();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsBindingPatternWithDefault_eq_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBindingPatternWithDefault::cast_ref(&*this).unwrap();
+    let result = this.eq_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsBindingPatternWithDefault_default<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBindingPatternWithDefault::cast_ref(&*this).unwrap();
+    let result = this.default();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsBlockStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsBlockStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsBlockStatement_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBlockStatement::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsBlockStatement_statements<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBlockStatement::cast_ref(&*this).unwrap();
+    let result = this.statements();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsBlockStatement_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBlockStatement::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsBooleanLiteralExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsBooleanLiteralExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsBooleanLiteralExpression_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBooleanLiteralExpression::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsBreakStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsBreakStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsBreakStatement_break_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBreakStatement::cast_ref(&*this).unwrap();
+    let result = this.break_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsBreakStatement_label_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBreakStatement::cast_ref(&*this).unwrap();
+    let result = this.label_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsBreakStatement_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsBreakStatement::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsCallArguments {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsCallArguments,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsCallArguments_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCallArguments::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsCallArguments_args<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCallArguments::cast_ref(&*this).unwrap();
+    let result = this.args();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsCallArguments_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCallArguments::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsCallExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsCallExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsCallExpression_callee<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCallExpression::cast_ref(&*this).unwrap();
+    let result = this.callee();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsCallExpression_optional_chain_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCallExpression::cast_ref(&*this).unwrap();
+    let result = this.optional_chain_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsCallExpression_type_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCallExpression::cast_ref(&*this).unwrap();
+    let result = this.type_arguments();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsCallExpression_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCallExpression::cast_ref(&*this).unwrap();
+    let result = this.arguments();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsCaseClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsCaseClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsCaseClause_case_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCaseClause::cast_ref(&*this).unwrap();
+    let result = this.case_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsCaseClause_test<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCaseClause::cast_ref(&*this).unwrap();
+    let result = this.test();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsCaseClause_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCaseClause::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsCaseClause_consequent<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCaseClause::cast_ref(&*this).unwrap();
+    let result = this.consequent();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsCatchClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsCatchClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsCatchClause_catch_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCatchClause::cast_ref(&*this).unwrap();
+    let result = this.catch_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsCatchClause_declaration<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCatchClause::cast_ref(&*this).unwrap();
+    let result = this.declaration();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsCatchClause_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCatchClause::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsCatchDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsCatchDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsCatchDeclaration_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCatchDeclaration::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsCatchDeclaration_binding<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCatchDeclaration::cast_ref(&*this).unwrap();
+    let result = this.binding();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsCatchDeclaration_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCatchDeclaration::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsCatchDeclaration_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsCatchDeclaration::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsClassDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsClassDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassDeclaration_decorators<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassDeclaration::cast_ref(&*this).unwrap();
+    let result = this.decorators();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsClassDeclaration_abstract_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassDeclaration::cast_ref(&*this).unwrap();
+    let result = this.abstract_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassDeclaration_class_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassDeclaration::cast_ref(&*this).unwrap();
+    let result = this.class_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassDeclaration_id<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassDeclaration::cast_ref(&*this).unwrap();
+    let result = this.id();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassDeclaration_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassDeclaration::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassDeclaration_extends_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassDeclaration::cast_ref(&*this).unwrap();
+    let result = this.extends_clause();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassDeclaration_implements_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassDeclaration::cast_ref(&*this).unwrap();
+    let result = this.implements_clause();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassDeclaration_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassDeclaration::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassDeclaration_members<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassDeclaration::cast_ref(&*this).unwrap();
+    let result = this.members();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsClassDeclaration_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassDeclaration::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsClassExportDefaultDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsClassExportDefaultDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExportDefaultDeclaration_decorators<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.decorators();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsClassExportDefaultDeclaration_abstract_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.abstract_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExportDefaultDeclaration_class_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.class_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExportDefaultDeclaration_id<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.id();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExportDefaultDeclaration_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExportDefaultDeclaration_extends_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.extends_clause();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExportDefaultDeclaration_implements_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.implements_clause();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExportDefaultDeclaration_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExportDefaultDeclaration_members<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.members();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsClassExportDefaultDeclaration_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsClassExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsClassExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExpression_decorators<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExpression::cast_ref(&*this).unwrap();
+    let result = this.decorators();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsClassExpression_class_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExpression::cast_ref(&*this).unwrap();
+    let result = this.class_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExpression_id<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExpression::cast_ref(&*this).unwrap();
+    let result = this.id();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExpression_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExpression::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExpression_extends_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExpression::cast_ref(&*this).unwrap();
+    let result = this.extends_clause();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExpression_implements_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExpression::cast_ref(&*this).unwrap();
+    let result = this.implements_clause();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExpression_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExpression::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsClassExpression_members<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExpression::cast_ref(&*this).unwrap();
+    let result = this.members();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsClassExpression_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsClassExpression::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsComputedMemberAssignment {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsComputedMemberAssignment,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsComputedMemberAssignment_object<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsComputedMemberAssignment::cast_ref(&*this).unwrap();
+    let result = this.object();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsComputedMemberAssignment_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsComputedMemberAssignment::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsComputedMemberAssignment_member<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsComputedMemberAssignment::cast_ref(&*this).unwrap();
+    let result = this.member();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsComputedMemberAssignment_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsComputedMemberAssignment::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsComputedMemberExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsComputedMemberExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsComputedMemberExpression_object<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsComputedMemberExpression::cast_ref(&*this).unwrap();
+    let result = this.object();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsComputedMemberExpression_optional_chain_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsComputedMemberExpression::cast_ref(&*this).unwrap();
+    let result = this.optional_chain_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsComputedMemberExpression_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsComputedMemberExpression::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsComputedMemberExpression_member<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsComputedMemberExpression::cast_ref(&*this).unwrap();
+    let result = this.member();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsComputedMemberExpression_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsComputedMemberExpression::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsComputedMemberName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsComputedMemberName,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsComputedMemberName_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsComputedMemberName::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsComputedMemberName_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsComputedMemberName::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsComputedMemberName_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsComputedMemberName::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsConditionalExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsConditionalExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsConditionalExpression_test<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsConditionalExpression::cast_ref(&*this).unwrap();
+    let result = this.test();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsConditionalExpression_question_mark_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsConditionalExpression::cast_ref(&*this).unwrap();
+    let result = this.question_mark_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsConditionalExpression_consequent<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsConditionalExpression::cast_ref(&*this).unwrap();
+    let result = this.consequent();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsConditionalExpression_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsConditionalExpression::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsConditionalExpression_alternate<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsConditionalExpression::cast_ref(&*this).unwrap();
+    let result = this.alternate();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsConstructorClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsConstructorClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsConstructorClassMember_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsConstructorClassMember::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsConstructorClassMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsConstructorClassMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsConstructorClassMember_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsConstructorClassMember::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsConstructorClassMember_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsConstructorClassMember::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsConstructorParameters {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsConstructorParameters,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsConstructorParameters_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsConstructorParameters::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsConstructorParameters_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsConstructorParameters::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsConstructorParameters_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsConstructorParameters::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsContinueStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsContinueStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsContinueStatement_continue_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsContinueStatement::cast_ref(&*this).unwrap();
+    let result = this.continue_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsContinueStatement_label_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsContinueStatement::cast_ref(&*this).unwrap();
+    let result = this.label_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsContinueStatement_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsContinueStatement::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsDebuggerStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsDebuggerStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsDebuggerStatement_debugger_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDebuggerStatement::cast_ref(&*this).unwrap();
+    let result = this.debugger_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsDebuggerStatement_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDebuggerStatement::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsDecorator {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsDecorator,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsDecorator_at_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDecorator::cast_ref(&*this).unwrap();
+    let result = this.at_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsDecorator_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDecorator::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsDefaultClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsDefaultClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsDefaultClause_default_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDefaultClause::cast_ref(&*this).unwrap();
+    let result = this.default_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsDefaultClause_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDefaultClause::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsDefaultClause_consequent<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDefaultClause::cast_ref(&*this).unwrap();
+    let result = this.consequent();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsDefaultImportSpecifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsDefaultImportSpecifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsDefaultImportSpecifier_local_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDefaultImportSpecifier::cast_ref(&*this).unwrap();
+    let result = this.local_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsDefaultImportSpecifier_trailing_comma_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDefaultImportSpecifier::cast_ref(&*this).unwrap();
+    let result = this.trailing_comma_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsDirective {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsDirective,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsDirective_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDirective::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsDirective_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDirective::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsDoWhileStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsDoWhileStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsDoWhileStatement_do_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDoWhileStatement::cast_ref(&*this).unwrap();
+    let result = this.do_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsDoWhileStatement_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDoWhileStatement::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsDoWhileStatement_while_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDoWhileStatement::cast_ref(&*this).unwrap();
+    let result = this.while_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsDoWhileStatement_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDoWhileStatement::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsDoWhileStatement_test<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDoWhileStatement::cast_ref(&*this).unwrap();
+    let result = this.test();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsDoWhileStatement_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDoWhileStatement::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsDoWhileStatement_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsDoWhileStatement::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsElseClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsElseClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsElseClause_else_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsElseClause::cast_ref(&*this).unwrap();
+    let result = this.else_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsElseClause_alternate<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsElseClause::cast_ref(&*this).unwrap();
+    let result = this.alternate();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsEmptyClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsEmptyClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsEmptyClassMember_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsEmptyClassMember::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsEmptyStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsEmptyStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsEmptyStatement_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsEmptyStatement::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExport {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExport,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExport_decorators<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExport::cast_ref(&*this).unwrap();
+    let result = this.decorators();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsExport_export_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExport::cast_ref(&*this).unwrap();
+    let result = this.export_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExport_export_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExport::cast_ref(&*this).unwrap();
+    let result = this.export_clause();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExportAsClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExportAsClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportAsClause_as_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportAsClause::cast_ref(&*this).unwrap();
+    let result = this.as_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportAsClause_exported_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportAsClause::cast_ref(&*this).unwrap();
+    let result = this.exported_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExportDefaultDeclarationClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExportDefaultDeclarationClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportDefaultDeclarationClause_default_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportDefaultDeclarationClause::cast_ref(&*this).unwrap();
+    let result = this.default_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportDefaultDeclarationClause_declaration<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportDefaultDeclarationClause::cast_ref(&*this).unwrap();
+    let result = this.declaration();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportDefaultDeclarationClause_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportDefaultDeclarationClause::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExportDefaultExpressionClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExportDefaultExpressionClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportDefaultExpressionClause_default_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportDefaultExpressionClause::cast_ref(&*this).unwrap();
+    let result = this.default_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportDefaultExpressionClause_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportDefaultExpressionClause::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportDefaultExpressionClause_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportDefaultExpressionClause::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExportFromClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExportFromClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportFromClause_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportFromClause::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportFromClause_star_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportFromClause::cast_ref(&*this).unwrap();
+    let result = this.star_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportFromClause_export_as<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportFromClause::cast_ref(&*this).unwrap();
+    let result = this.export_as();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportFromClause_from_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportFromClause::cast_ref(&*this).unwrap();
+    let result = this.from_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportFromClause_source<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportFromClause::cast_ref(&*this).unwrap();
+    let result = this.source();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportFromClause_assertion<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportFromClause::cast_ref(&*this).unwrap();
+    let result = this.assertion();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportFromClause_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportFromClause::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExportNamedClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExportNamedClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedClause_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedClause::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedClause_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedClause::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedClause_specifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedClause::cast_ref(&*this).unwrap();
+    let result = this.specifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsExportNamedClause_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedClause::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedClause_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedClause::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExportNamedFromClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExportNamedFromClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedFromClause_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedFromClause::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedFromClause_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedFromClause::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedFromClause_specifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedFromClause::cast_ref(&*this).unwrap();
+    let result = this.specifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsExportNamedFromClause_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedFromClause::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedFromClause_from_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedFromClause::cast_ref(&*this).unwrap();
+    let result = this.from_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedFromClause_source<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedFromClause::cast_ref(&*this).unwrap();
+    let result = this.source();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedFromClause_assertion<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedFromClause::cast_ref(&*this).unwrap();
+    let result = this.assertion();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedFromClause_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedFromClause::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExportNamedFromSpecifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExportNamedFromSpecifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedFromSpecifier_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedFromSpecifier::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedFromSpecifier_source_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedFromSpecifier::cast_ref(&*this).unwrap();
+    let result = this.source_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedFromSpecifier_export_as<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedFromSpecifier::cast_ref(&*this).unwrap();
+    let result = this.export_as();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExportNamedShorthandSpecifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExportNamedShorthandSpecifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedShorthandSpecifier_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedShorthandSpecifier::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedShorthandSpecifier_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedShorthandSpecifier::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExportNamedSpecifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExportNamedSpecifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedSpecifier_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedSpecifier::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedSpecifier_local_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedSpecifier::cast_ref(&*this).unwrap();
+    let result = this.local_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedSpecifier_as_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedSpecifier::cast_ref(&*this).unwrap();
+    let result = this.as_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExportNamedSpecifier_exported_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExportNamedSpecifier::cast_ref(&*this).unwrap();
+    let result = this.exported_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExpressionSnipped {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExpressionSnipped,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExpressionSnipped_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExpressionSnipped::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExpressionSnipped_eof_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExpressionSnipped::cast_ref(&*this).unwrap();
+    let result = this.eof_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExpressionStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExpressionStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExpressionStatement_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExpressionStatement::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExpressionStatement_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExpressionStatement::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsExtendsClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsExtendsClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsExtendsClause_extends_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExtendsClause::cast_ref(&*this).unwrap();
+    let result = this.extends_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExtendsClause_super_class<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExtendsClause::cast_ref(&*this).unwrap();
+    let result = this.super_class();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsExtendsClause_type_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsExtendsClause::cast_ref(&*this).unwrap();
+    let result = this.type_arguments();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsFinallyClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsFinallyClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsFinallyClause_finally_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFinallyClause::cast_ref(&*this).unwrap();
+    let result = this.finally_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsFinallyClause_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFinallyClause::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsForInStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsForInStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsForInStatement_for_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForInStatement::cast_ref(&*this).unwrap();
+    let result = this.for_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForInStatement_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForInStatement::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForInStatement_initializer<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForInStatement::cast_ref(&*this).unwrap();
+    let result = this.initializer();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForInStatement_in_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForInStatement::cast_ref(&*this).unwrap();
+    let result = this.in_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForInStatement_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForInStatement::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForInStatement_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForInStatement::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForInStatement_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForInStatement::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsForOfStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsForOfStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsForOfStatement_for_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForOfStatement::cast_ref(&*this).unwrap();
+    let result = this.for_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForOfStatement_await_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForOfStatement::cast_ref(&*this).unwrap();
+    let result = this.await_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsForOfStatement_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForOfStatement::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForOfStatement_initializer<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForOfStatement::cast_ref(&*this).unwrap();
+    let result = this.initializer();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForOfStatement_of_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForOfStatement::cast_ref(&*this).unwrap();
+    let result = this.of_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForOfStatement_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForOfStatement::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForOfStatement_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForOfStatement::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForOfStatement_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForOfStatement::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsForStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsForStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsForStatement_for_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForStatement::cast_ref(&*this).unwrap();
+    let result = this.for_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForStatement_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForStatement::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForStatement_initializer<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForStatement::cast_ref(&*this).unwrap();
+    let result = this.initializer();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsForStatement_first_semi_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForStatement::cast_ref(&*this).unwrap();
+    let result = this.first_semi_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForStatement_test<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForStatement::cast_ref(&*this).unwrap();
+    let result = this.test();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsForStatement_second_semi_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForStatement::cast_ref(&*this).unwrap();
+    let result = this.second_semi_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForStatement_update<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForStatement::cast_ref(&*this).unwrap();
+    let result = this.update();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsForStatement_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForStatement::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForStatement_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForStatement::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsForVariableDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsForVariableDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsForVariableDeclaration_kind_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForVariableDeclaration::cast_ref(&*this).unwrap();
+    let result = this.kind_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsForVariableDeclaration_declarator<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsForVariableDeclaration::cast_ref(&*this).unwrap();
+    let result = this.declarator();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsFormalParameter {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsFormalParameter,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsFormalParameter_decorators<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFormalParameter::cast_ref(&*this).unwrap();
+    let result = this.decorators();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsFormalParameter_binding<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFormalParameter::cast_ref(&*this).unwrap();
+    let result = this.binding();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsFormalParameter_question_mark_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFormalParameter::cast_ref(&*this).unwrap();
+    let result = this.question_mark_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFormalParameter_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFormalParameter::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFormalParameter_initializer<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFormalParameter::cast_ref(&*this).unwrap();
+    let result = this.initializer();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsFunctionBody {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsFunctionBody,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionBody_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionBody::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionBody_directives<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionBody::cast_ref(&*this).unwrap();
+    let result = this.directives();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsFunctionBody_statements<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionBody::cast_ref(&*this).unwrap();
+    let result = this.statements();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsFunctionBody_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionBody::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsFunctionDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsFunctionDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionDeclaration_async_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.async_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionDeclaration_function_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.function_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionDeclaration_star_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.star_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionDeclaration_id<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.id();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionDeclaration_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionDeclaration_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionDeclaration_return_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.return_type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionDeclaration_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsFunctionExportDefaultDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsFunctionExportDefaultDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExportDefaultDeclaration_async_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.async_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExportDefaultDeclaration_function_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.function_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExportDefaultDeclaration_star_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.star_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExportDefaultDeclaration_id<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.id();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExportDefaultDeclaration_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExportDefaultDeclaration_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExportDefaultDeclaration_return_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.return_type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExportDefaultDeclaration_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsFunctionExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsFunctionExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExpression_async_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.async_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExpression_function_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.function_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExpression_star_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.star_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExpression_id<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.id();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExpression_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExpression_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExpression_return_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.return_type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsFunctionExpression_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsFunctionExpression::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsGetterClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsGetterClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsGetterClassMember_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsGetterClassMember_get_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.get_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsGetterClassMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsGetterClassMember_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsGetterClassMember_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsGetterClassMember_return_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.return_type();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsGetterClassMember_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsGetterObjectMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsGetterObjectMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsGetterObjectMember_get_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterObjectMember::cast_ref(&*this).unwrap();
+    let result = this.get_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsGetterObjectMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterObjectMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsGetterObjectMember_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterObjectMember::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsGetterObjectMember_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterObjectMember::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsGetterObjectMember_return_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterObjectMember::cast_ref(&*this).unwrap();
+    let result = this.return_type();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsGetterObjectMember_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsGetterObjectMember::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsIdentifierAssignment {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsIdentifierAssignment,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsIdentifierAssignment_name_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsIdentifierAssignment::cast_ref(&*this).unwrap();
+    let result = this.name_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsIdentifierBinding {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsIdentifierBinding,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsIdentifierBinding_name_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsIdentifierBinding::cast_ref(&*this).unwrap();
+    let result = this.name_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsIdentifierExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsIdentifierExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsIdentifierExpression_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsIdentifierExpression::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsIfStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsIfStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsIfStatement_if_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsIfStatement::cast_ref(&*this).unwrap();
+    let result = this.if_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsIfStatement_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsIfStatement::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsIfStatement_test<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsIfStatement::cast_ref(&*this).unwrap();
+    let result = this.test();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsIfStatement_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsIfStatement::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsIfStatement_consequent<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsIfStatement::cast_ref(&*this).unwrap();
+    let result = this.consequent();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsIfStatement_else_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsIfStatement::cast_ref(&*this).unwrap();
+    let result = this.else_clause();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsImport {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsImport,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsImport_import_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImport::cast_ref(&*this).unwrap();
+    let result = this.import_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImport_import_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImport::cast_ref(&*this).unwrap();
+    let result = this.import_clause();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImport_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImport::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsImportAssertion {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsImportAssertion,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportAssertion_assertion_kind<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportAssertion::cast_ref(&*this).unwrap();
+    let result = this.assertion_kind();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportAssertion_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportAssertion::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportAssertion_assertions<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportAssertion::cast_ref(&*this).unwrap();
+    let result = this.assertions();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsImportAssertion_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportAssertion::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsImportAssertionEntry {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsImportAssertionEntry,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportAssertionEntry_key<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportAssertionEntry::cast_ref(&*this).unwrap();
+    let result = this.key();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportAssertionEntry_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportAssertionEntry::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportAssertionEntry_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportAssertionEntry::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsImportBareClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsImportBareClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportBareClause_source<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportBareClause::cast_ref(&*this).unwrap();
+    let result = this.source();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportBareClause_assertion<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportBareClause::cast_ref(&*this).unwrap();
+    let result = this.assertion();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsImportCallExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsImportCallExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportCallExpression_import_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportCallExpression::cast_ref(&*this).unwrap();
+    let result = this.import_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportCallExpression_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportCallExpression::cast_ref(&*this).unwrap();
+    let result = this.arguments();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsImportDefaultClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsImportDefaultClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportDefaultClause_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportDefaultClause::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportDefaultClause_local_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportDefaultClause::cast_ref(&*this).unwrap();
+    let result = this.local_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportDefaultClause_from_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportDefaultClause::cast_ref(&*this).unwrap();
+    let result = this.from_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportDefaultClause_source<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportDefaultClause::cast_ref(&*this).unwrap();
+    let result = this.source();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportDefaultClause_assertion<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportDefaultClause::cast_ref(&*this).unwrap();
+    let result = this.assertion();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsImportMetaExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsImportMetaExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportMetaExpression_import_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportMetaExpression::cast_ref(&*this).unwrap();
+    let result = this.import_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportMetaExpression_dot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportMetaExpression::cast_ref(&*this).unwrap();
+    let result = this.dot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportMetaExpression_meta_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportMetaExpression::cast_ref(&*this).unwrap();
+    let result = this.meta_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsImportNamedClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsImportNamedClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamedClause_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamedClause::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamedClause_default_specifier<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamedClause::cast_ref(&*this).unwrap();
+    let result = this.default_specifier();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamedClause_named_import<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamedClause::cast_ref(&*this).unwrap();
+    let result = this.named_import();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamedClause_from_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamedClause::cast_ref(&*this).unwrap();
+    let result = this.from_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamedClause_source<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamedClause::cast_ref(&*this).unwrap();
+    let result = this.source();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamedClause_assertion<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamedClause::cast_ref(&*this).unwrap();
+    let result = this.assertion();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsImportNamespaceClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsImportNamespaceClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamespaceClause_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamespaceClause::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamespaceClause_star_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamespaceClause::cast_ref(&*this).unwrap();
+    let result = this.star_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamespaceClause_as_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamespaceClause::cast_ref(&*this).unwrap();
+    let result = this.as_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamespaceClause_local_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamespaceClause::cast_ref(&*this).unwrap();
+    let result = this.local_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamespaceClause_from_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamespaceClause::cast_ref(&*this).unwrap();
+    let result = this.from_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamespaceClause_source<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamespaceClause::cast_ref(&*this).unwrap();
+    let result = this.source();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsImportNamespaceClause_assertion<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsImportNamespaceClause::cast_ref(&*this).unwrap();
+    let result = this.assertion();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsInExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsInExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsInExpression_property<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsInExpression::cast_ref(&*this).unwrap();
+    let result = this.property();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsInExpression_in_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsInExpression::cast_ref(&*this).unwrap();
+    let result = this.in_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsInExpression_object<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsInExpression::cast_ref(&*this).unwrap();
+    let result = this.object();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsInitializerClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsInitializerClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsInitializerClause_eq_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsInitializerClause::cast_ref(&*this).unwrap();
+    let result = this.eq_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsInitializerClause_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsInitializerClause::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsInstanceofExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsInstanceofExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsInstanceofExpression_left<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsInstanceofExpression::cast_ref(&*this).unwrap();
+    let result = this.left();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsInstanceofExpression_instanceof_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsInstanceofExpression::cast_ref(&*this).unwrap();
+    let result = this.instanceof_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsInstanceofExpression_right<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsInstanceofExpression::cast_ref(&*this).unwrap();
+    let result = this.right();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsLabeledStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsLabeledStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsLabeledStatement_label_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsLabeledStatement::cast_ref(&*this).unwrap();
+    let result = this.label_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsLabeledStatement_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsLabeledStatement::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsLabeledStatement_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsLabeledStatement::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsLiteralExportName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsLiteralExportName,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsLiteralExportName_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsLiteralExportName::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsLiteralMemberName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsLiteralMemberName,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsLiteralMemberName_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsLiteralMemberName::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsLogicalExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsLogicalExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsLogicalExpression_left<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsLogicalExpression::cast_ref(&*this).unwrap();
+    let result = this.left();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsLogicalExpression_operator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsLogicalExpression::cast_ref(&*this).unwrap();
+    let result = this.operator_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsLogicalExpression_right<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsLogicalExpression::cast_ref(&*this).unwrap();
+    let result = this.right();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsMethodClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsMethodClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodClassMember_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodClassMember::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsMethodClassMember_async_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodClassMember::cast_ref(&*this).unwrap();
+    let result = this.async_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodClassMember_star_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodClassMember::cast_ref(&*this).unwrap();
+    let result = this.star_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodClassMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodClassMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodClassMember_question_mark_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodClassMember::cast_ref(&*this).unwrap();
+    let result = this.question_mark_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodClassMember_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodClassMember::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodClassMember_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodClassMember::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodClassMember_return_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodClassMember::cast_ref(&*this).unwrap();
+    let result = this.return_type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodClassMember_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodClassMember::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsMethodObjectMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsMethodObjectMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodObjectMember_async_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodObjectMember::cast_ref(&*this).unwrap();
+    let result = this.async_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodObjectMember_star_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodObjectMember::cast_ref(&*this).unwrap();
+    let result = this.star_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodObjectMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodObjectMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodObjectMember_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodObjectMember::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodObjectMember_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodObjectMember::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodObjectMember_return_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodObjectMember::cast_ref(&*this).unwrap();
+    let result = this.return_type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsMethodObjectMember_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsMethodObjectMember::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsModule {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsModule,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsModule_interpreter_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsModule::cast_ref(&*this).unwrap();
+    let result = this.interpreter_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsModule_directives<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsModule::cast_ref(&*this).unwrap();
+    let result = this.directives();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsModule_items<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsModule::cast_ref(&*this).unwrap();
+    let result = this.items();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsModule_eof_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsModule::cast_ref(&*this).unwrap();
+    let result = this.eof_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsModuleSource {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsModuleSource,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsModuleSource_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsModuleSource::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsName,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsName_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsName::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsNamedImportSpecifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsNamedImportSpecifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsNamedImportSpecifier_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNamedImportSpecifier::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsNamedImportSpecifier_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNamedImportSpecifier::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsNamedImportSpecifier_as_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNamedImportSpecifier::cast_ref(&*this).unwrap();
+    let result = this.as_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsNamedImportSpecifier_local_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNamedImportSpecifier::cast_ref(&*this).unwrap();
+    let result = this.local_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsNamedImportSpecifiers {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsNamedImportSpecifiers,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsNamedImportSpecifiers_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNamedImportSpecifiers::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsNamedImportSpecifiers_specifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNamedImportSpecifiers::cast_ref(&*this).unwrap();
+    let result = this.specifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsNamedImportSpecifiers_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNamedImportSpecifiers::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsNamespaceImportSpecifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsNamespaceImportSpecifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsNamespaceImportSpecifier_star_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNamespaceImportSpecifier::cast_ref(&*this).unwrap();
+    let result = this.star_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsNamespaceImportSpecifier_as_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNamespaceImportSpecifier::cast_ref(&*this).unwrap();
+    let result = this.as_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsNamespaceImportSpecifier_local_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNamespaceImportSpecifier::cast_ref(&*this).unwrap();
+    let result = this.local_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsNewExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsNewExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsNewExpression_new_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNewExpression::cast_ref(&*this).unwrap();
+    let result = this.new_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsNewExpression_callee<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNewExpression::cast_ref(&*this).unwrap();
+    let result = this.callee();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsNewExpression_type_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNewExpression::cast_ref(&*this).unwrap();
+    let result = this.type_arguments();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsNewExpression_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNewExpression::cast_ref(&*this).unwrap();
+    let result = this.arguments();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsNewTargetExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsNewTargetExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsNewTargetExpression_new_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNewTargetExpression::cast_ref(&*this).unwrap();
+    let result = this.new_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsNewTargetExpression_dot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNewTargetExpression::cast_ref(&*this).unwrap();
+    let result = this.dot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsNewTargetExpression_target_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNewTargetExpression::cast_ref(&*this).unwrap();
+    let result = this.target_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsNullLiteralExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsNullLiteralExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsNullLiteralExpression_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNullLiteralExpression::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsNumberLiteralExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsNumberLiteralExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsNumberLiteralExpression_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsNumberLiteralExpression::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsObjectAssignmentPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsObjectAssignmentPattern,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectAssignmentPattern_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectAssignmentPattern::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectAssignmentPattern_properties<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectAssignmentPattern::cast_ref(&*this).unwrap();
+    let result = this.properties();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsObjectAssignmentPattern_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectAssignmentPattern::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsObjectAssignmentPatternProperty {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsObjectAssignmentPatternProperty,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectAssignmentPatternProperty_member<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectAssignmentPatternProperty::cast_ref(&*this).unwrap();
+    let result = this.member();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectAssignmentPatternProperty_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectAssignmentPatternProperty::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectAssignmentPatternProperty_pattern<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectAssignmentPatternProperty::cast_ref(&*this).unwrap();
+    let result = this.pattern();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectAssignmentPatternProperty_init<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectAssignmentPatternProperty::cast_ref(&*this).unwrap();
+    let result = this.init();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsObjectAssignmentPatternRest {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsObjectAssignmentPatternRest,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectAssignmentPatternRest_dotdotdot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectAssignmentPatternRest::cast_ref(&*this).unwrap();
+    let result = this.dotdotdot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectAssignmentPatternRest_target<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectAssignmentPatternRest::cast_ref(&*this).unwrap();
+    let result = this.target();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsObjectAssignmentPatternShorthandProperty {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsObjectAssignmentPatternShorthandProperty,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectAssignmentPatternShorthandProperty_identifier<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this =
+        rome_js_syntax::JsObjectAssignmentPatternShorthandProperty::cast_ref(&*this).unwrap();
+    let result = this.identifier();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectAssignmentPatternShorthandProperty_init<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this =
+        rome_js_syntax::JsObjectAssignmentPatternShorthandProperty::cast_ref(&*this).unwrap();
+    let result = this.init();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsObjectBindingPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsObjectBindingPattern,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectBindingPattern_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectBindingPattern::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectBindingPattern_properties<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectBindingPattern::cast_ref(&*this).unwrap();
+    let result = this.properties();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsObjectBindingPattern_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectBindingPattern::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsObjectBindingPatternProperty {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsObjectBindingPatternProperty,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectBindingPatternProperty_member<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectBindingPatternProperty::cast_ref(&*this).unwrap();
+    let result = this.member();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectBindingPatternProperty_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectBindingPatternProperty::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectBindingPatternProperty_pattern<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectBindingPatternProperty::cast_ref(&*this).unwrap();
+    let result = this.pattern();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectBindingPatternProperty_init<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectBindingPatternProperty::cast_ref(&*this).unwrap();
+    let result = this.init();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsObjectBindingPatternRest {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsObjectBindingPatternRest,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectBindingPatternRest_dotdotdot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectBindingPatternRest::cast_ref(&*this).unwrap();
+    let result = this.dotdotdot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectBindingPatternRest_binding<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectBindingPatternRest::cast_ref(&*this).unwrap();
+    let result = this.binding();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsObjectBindingPatternShorthandProperty {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsObjectBindingPatternShorthandProperty,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectBindingPatternShorthandProperty_identifier<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectBindingPatternShorthandProperty::cast_ref(&*this).unwrap();
+    let result = this.identifier();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectBindingPatternShorthandProperty_init<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectBindingPatternShorthandProperty::cast_ref(&*this).unwrap();
+    let result = this.init();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsObjectExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsObjectExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectExpression_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectExpression::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsObjectExpression_members<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectExpression::cast_ref(&*this).unwrap();
+    let result = this.members();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsObjectExpression_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsObjectExpression::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsParameters {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsParameters,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsParameters_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsParameters::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsParameters_items<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsParameters::cast_ref(&*this).unwrap();
+    let result = this.items();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsParameters_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsParameters::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsParenthesizedAssignment {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsParenthesizedAssignment,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsParenthesizedAssignment_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsParenthesizedAssignment::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsParenthesizedAssignment_assignment<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsParenthesizedAssignment::cast_ref(&*this).unwrap();
+    let result = this.assignment();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsParenthesizedAssignment_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsParenthesizedAssignment::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsParenthesizedExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsParenthesizedExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsParenthesizedExpression_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsParenthesizedExpression::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsParenthesizedExpression_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsParenthesizedExpression::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsParenthesizedExpression_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsParenthesizedExpression::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsPostUpdateExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsPostUpdateExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsPostUpdateExpression_operand<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPostUpdateExpression::cast_ref(&*this).unwrap();
+    let result = this.operand();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsPostUpdateExpression_operator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPostUpdateExpression::cast_ref(&*this).unwrap();
+    let result = this.operator_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsPreUpdateExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsPreUpdateExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsPreUpdateExpression_operator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPreUpdateExpression::cast_ref(&*this).unwrap();
+    let result = this.operator_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsPreUpdateExpression_operand<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPreUpdateExpression::cast_ref(&*this).unwrap();
+    let result = this.operand();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsPrivateClassMemberName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsPrivateClassMemberName,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsPrivateClassMemberName_hash_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPrivateClassMemberName::cast_ref(&*this).unwrap();
+    let result = this.hash_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsPrivateClassMemberName_id_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPrivateClassMemberName::cast_ref(&*this).unwrap();
+    let result = this.id_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsPrivateName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsPrivateName,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsPrivateName_hash_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPrivateName::cast_ref(&*this).unwrap();
+    let result = this.hash_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsPrivateName_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPrivateName::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsPropertyClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsPropertyClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsPropertyClassMember_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPropertyClassMember::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsPropertyClassMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPropertyClassMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsPropertyClassMember_property_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPropertyClassMember::cast_ref(&*this).unwrap();
+    let result = this.property_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsPropertyClassMember_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPropertyClassMember::cast_ref(&*this).unwrap();
+    let result = this.value();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsPropertyClassMember_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPropertyClassMember::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsPropertyObjectMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsPropertyObjectMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsPropertyObjectMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPropertyObjectMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsPropertyObjectMember_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPropertyObjectMember::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsPropertyObjectMember_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsPropertyObjectMember::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsReferenceIdentifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsReferenceIdentifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsReferenceIdentifier_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsReferenceIdentifier::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsRegexLiteralExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsRegexLiteralExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsRegexLiteralExpression_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsRegexLiteralExpression::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsRestParameter {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsRestParameter,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsRestParameter_decorators<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsRestParameter::cast_ref(&*this).unwrap();
+    let result = this.decorators();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsRestParameter_dotdotdot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsRestParameter::cast_ref(&*this).unwrap();
+    let result = this.dotdotdot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsRestParameter_binding<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsRestParameter::cast_ref(&*this).unwrap();
+    let result = this.binding();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsRestParameter_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsRestParameter::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsReturnStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsReturnStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsReturnStatement_return_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsReturnStatement::cast_ref(&*this).unwrap();
+    let result = this.return_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsReturnStatement_argument<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsReturnStatement::cast_ref(&*this).unwrap();
+    let result = this.argument();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsReturnStatement_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsReturnStatement::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsScript {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsScript,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsScript_interpreter_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsScript::cast_ref(&*this).unwrap();
+    let result = this.interpreter_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsScript_directives<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsScript::cast_ref(&*this).unwrap();
+    let result = this.directives();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsScript_statements<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsScript::cast_ref(&*this).unwrap();
+    let result = this.statements();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsScript_eof_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsScript::cast_ref(&*this).unwrap();
+    let result = this.eof_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsSequenceExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsSequenceExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsSequenceExpression_left<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSequenceExpression::cast_ref(&*this).unwrap();
+    let result = this.left();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSequenceExpression_comma_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSequenceExpression::cast_ref(&*this).unwrap();
+    let result = this.comma_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSequenceExpression_right<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSequenceExpression::cast_ref(&*this).unwrap();
+    let result = this.right();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsSetterClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsSetterClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsSetterClassMember_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsSetterClassMember_set_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.set_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSetterClassMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSetterClassMember_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSetterClassMember_parameter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.parameter();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSetterClassMember_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSetterClassMember_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterClassMember::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsSetterObjectMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsSetterObjectMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsSetterObjectMember_set_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterObjectMember::cast_ref(&*this).unwrap();
+    let result = this.set_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSetterObjectMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterObjectMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSetterObjectMember_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterObjectMember::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSetterObjectMember_parameter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterObjectMember::cast_ref(&*this).unwrap();
+    let result = this.parameter();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSetterObjectMember_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterObjectMember::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSetterObjectMember_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSetterObjectMember::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsShorthandNamedImportSpecifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsShorthandNamedImportSpecifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsShorthandNamedImportSpecifier_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsShorthandNamedImportSpecifier::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsShorthandNamedImportSpecifier_local_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsShorthandNamedImportSpecifier::cast_ref(&*this).unwrap();
+    let result = this.local_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsShorthandPropertyObjectMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsShorthandPropertyObjectMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsShorthandPropertyObjectMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsShorthandPropertyObjectMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsSpread {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsSpread,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsSpread_dotdotdot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSpread::cast_ref(&*this).unwrap();
+    let result = this.dotdotdot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSpread_argument<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSpread::cast_ref(&*this).unwrap();
+    let result = this.argument();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsStaticInitializationBlockClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsStaticInitializationBlockClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsStaticInitializationBlockClassMember_static_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsStaticInitializationBlockClassMember::cast_ref(&*this).unwrap();
+    let result = this.static_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsStaticInitializationBlockClassMember_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsStaticInitializationBlockClassMember::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsStaticInitializationBlockClassMember_statements<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsStaticInitializationBlockClassMember::cast_ref(&*this).unwrap();
+    let result = this.statements();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsStaticInitializationBlockClassMember_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsStaticInitializationBlockClassMember::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsStaticMemberAssignment {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsStaticMemberAssignment,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsStaticMemberAssignment_object<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsStaticMemberAssignment::cast_ref(&*this).unwrap();
+    let result = this.object();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsStaticMemberAssignment_dot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsStaticMemberAssignment::cast_ref(&*this).unwrap();
+    let result = this.dot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsStaticMemberAssignment_member<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsStaticMemberAssignment::cast_ref(&*this).unwrap();
+    let result = this.member();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsStaticMemberExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsStaticMemberExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsStaticMemberExpression_object<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsStaticMemberExpression::cast_ref(&*this).unwrap();
+    let result = this.object();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsStaticMemberExpression_operator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsStaticMemberExpression::cast_ref(&*this).unwrap();
+    let result = this.operator_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsStaticMemberExpression_member<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsStaticMemberExpression::cast_ref(&*this).unwrap();
+    let result = this.member();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsStaticModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsStaticModifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsStaticModifier_modifier_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsStaticModifier::cast_ref(&*this).unwrap();
+    let result = this.modifier_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsStringLiteralExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsStringLiteralExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsStringLiteralExpression_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsStringLiteralExpression::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsSuperExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsSuperExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsSuperExpression_super_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSuperExpression::cast_ref(&*this).unwrap();
+    let result = this.super_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsSwitchStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsSwitchStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsSwitchStatement_switch_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSwitchStatement::cast_ref(&*this).unwrap();
+    let result = this.switch_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSwitchStatement_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSwitchStatement::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSwitchStatement_discriminant<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSwitchStatement::cast_ref(&*this).unwrap();
+    let result = this.discriminant();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSwitchStatement_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSwitchStatement::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSwitchStatement_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSwitchStatement::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsSwitchStatement_cases<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSwitchStatement::cast_ref(&*this).unwrap();
+    let result = this.cases();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsSwitchStatement_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsSwitchStatement::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsTemplateChunkElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsTemplateChunkElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsTemplateChunkElement_template_chunk_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTemplateChunkElement::cast_ref(&*this).unwrap();
+    let result = this.template_chunk_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsTemplateElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsTemplateElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsTemplateElement_dollar_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTemplateElement::cast_ref(&*this).unwrap();
+    let result = this.dollar_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsTemplateElement_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTemplateElement::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsTemplateElement_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTemplateElement::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsTemplateExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsTemplateExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsTemplateExpression_tag<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTemplateExpression::cast_ref(&*this).unwrap();
+    let result = this.tag();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsTemplateExpression_type_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTemplateExpression::cast_ref(&*this).unwrap();
+    let result = this.type_arguments();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsTemplateExpression_l_tick_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTemplateExpression::cast_ref(&*this).unwrap();
+    let result = this.l_tick_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsTemplateExpression_elements<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTemplateExpression::cast_ref(&*this).unwrap();
+    let result = this.elements();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsTemplateExpression_r_tick_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTemplateExpression::cast_ref(&*this).unwrap();
+    let result = this.r_tick_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsThisExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsThisExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsThisExpression_this_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsThisExpression::cast_ref(&*this).unwrap();
+    let result = this.this_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsThrowStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsThrowStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsThrowStatement_throw_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsThrowStatement::cast_ref(&*this).unwrap();
+    let result = this.throw_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsThrowStatement_argument<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsThrowStatement::cast_ref(&*this).unwrap();
+    let result = this.argument();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsThrowStatement_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsThrowStatement::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsTryFinallyStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsTryFinallyStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsTryFinallyStatement_try_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTryFinallyStatement::cast_ref(&*this).unwrap();
+    let result = this.try_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsTryFinallyStatement_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTryFinallyStatement::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsTryFinallyStatement_catch_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTryFinallyStatement::cast_ref(&*this).unwrap();
+    let result = this.catch_clause();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsTryFinallyStatement_finally_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTryFinallyStatement::cast_ref(&*this).unwrap();
+    let result = this.finally_clause();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsTryStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsTryStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsTryStatement_try_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTryStatement::cast_ref(&*this).unwrap();
+    let result = this.try_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsTryStatement_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTryStatement::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsTryStatement_catch_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsTryStatement::cast_ref(&*this).unwrap();
+    let result = this.catch_clause();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsUnaryExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsUnaryExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsUnaryExpression_operator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsUnaryExpression::cast_ref(&*this).unwrap();
+    let result = this.operator_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsUnaryExpression_argument<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsUnaryExpression::cast_ref(&*this).unwrap();
+    let result = this.argument();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsVariableDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsVariableDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsVariableDeclaration_kind<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsVariableDeclaration::cast_ref(&*this).unwrap();
+    let result = this.kind();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsVariableDeclaration_declarators<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsVariableDeclaration::cast_ref(&*this).unwrap();
+    let result = this.declarators();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsVariableDeclarationClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsVariableDeclarationClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsVariableDeclarationClause_declaration<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsVariableDeclarationClause::cast_ref(&*this).unwrap();
+    let result = this.declaration();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsVariableDeclarationClause_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsVariableDeclarationClause::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsVariableDeclarator {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsVariableDeclarator,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsVariableDeclarator_id<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsVariableDeclarator::cast_ref(&*this).unwrap();
+    let result = this.id();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsVariableDeclarator_variable_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsVariableDeclarator::cast_ref(&*this).unwrap();
+    let result = this.variable_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsVariableDeclarator_initializer<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsVariableDeclarator::cast_ref(&*this).unwrap();
+    let result = this.initializer();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsVariableStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsVariableStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsVariableStatement_declaration<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsVariableStatement::cast_ref(&*this).unwrap();
+    let result = this.declaration();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsVariableStatement_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsVariableStatement::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsWhileStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsWhileStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsWhileStatement_while_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsWhileStatement::cast_ref(&*this).unwrap();
+    let result = this.while_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsWhileStatement_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsWhileStatement::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsWhileStatement_test<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsWhileStatement::cast_ref(&*this).unwrap();
+    let result = this.test();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsWhileStatement_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsWhileStatement::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsWhileStatement_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsWhileStatement::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsWithStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsWithStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsWithStatement_with_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsWithStatement::cast_ref(&*this).unwrap();
+    let result = this.with_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsWithStatement_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsWithStatement::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsWithStatement_object<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsWithStatement::cast_ref(&*this).unwrap();
+    let result = this.object();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsWithStatement_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsWithStatement::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsWithStatement_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsWithStatement::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsYieldArgument {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsYieldArgument,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsYieldArgument_star_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsYieldArgument::cast_ref(&*this).unwrap();
+    let result = this.star_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsYieldArgument_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsYieldArgument::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsYieldExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsYieldExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsYieldExpression_yield_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsYieldExpression::cast_ref(&*this).unwrap();
+    let result = this.yield_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsYieldExpression_argument<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsYieldExpression::cast_ref(&*this).unwrap();
+    let result = this.argument();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxAttribute {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxAttribute,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxAttribute_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxAttribute::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxAttribute_initializer<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxAttribute::cast_ref(&*this).unwrap();
+    let result = this.initializer();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxAttributeInitializerClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxAttributeInitializerClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxAttributeInitializerClause_eq_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxAttributeInitializerClause::cast_ref(&*this).unwrap();
+    let result = this.eq_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxAttributeInitializerClause_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxAttributeInitializerClause::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxClosingElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxClosingElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxClosingElement_l_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxClosingElement::cast_ref(&*this).unwrap();
+    let result = this.l_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxClosingElement_slash_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxClosingElement::cast_ref(&*this).unwrap();
+    let result = this.slash_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxClosingElement_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxClosingElement::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxClosingElement_r_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxClosingElement::cast_ref(&*this).unwrap();
+    let result = this.r_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxClosingFragment {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxClosingFragment,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxClosingFragment_l_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxClosingFragment::cast_ref(&*this).unwrap();
+    let result = this.l_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxClosingFragment_slash_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxClosingFragment::cast_ref(&*this).unwrap();
+    let result = this.slash_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxClosingFragment_r_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxClosingFragment::cast_ref(&*this).unwrap();
+    let result = this.r_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxElement_opening_element<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxElement::cast_ref(&*this).unwrap();
+    let result = this.opening_element();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxElement_children<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxElement::cast_ref(&*this).unwrap();
+    let result = this.children();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsxElement_closing_element<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxElement::cast_ref(&*this).unwrap();
+    let result = this.closing_element();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxExpressionAttributeValue {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxExpressionAttributeValue,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxExpressionAttributeValue_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxExpressionAttributeValue::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxExpressionAttributeValue_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxExpressionAttributeValue::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxExpressionAttributeValue_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxExpressionAttributeValue::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxExpressionChild {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxExpressionChild,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxExpressionChild_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxExpressionChild::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxExpressionChild_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxExpressionChild::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsxExpressionChild_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxExpressionChild::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxFragment {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxFragment,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxFragment_opening_fragment<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxFragment::cast_ref(&*this).unwrap();
+    let result = this.opening_fragment();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxFragment_children<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxFragment::cast_ref(&*this).unwrap();
+    let result = this.children();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsxFragment_closing_fragment<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxFragment::cast_ref(&*this).unwrap();
+    let result = this.closing_fragment();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxMemberName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxMemberName,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxMemberName_object<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxMemberName::cast_ref(&*this).unwrap();
+    let result = this.object();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxMemberName_dot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxMemberName::cast_ref(&*this).unwrap();
+    let result = this.dot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxMemberName_member<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxMemberName::cast_ref(&*this).unwrap();
+    let result = this.member();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxName,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxName_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxName::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxNamespaceName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxNamespaceName,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxNamespaceName_namespace<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxNamespaceName::cast_ref(&*this).unwrap();
+    let result = this.namespace();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxNamespaceName_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxNamespaceName::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxNamespaceName_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxNamespaceName::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxOpeningElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxOpeningElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxOpeningElement_l_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxOpeningElement::cast_ref(&*this).unwrap();
+    let result = this.l_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxOpeningElement_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxOpeningElement::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxOpeningElement_type_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxOpeningElement::cast_ref(&*this).unwrap();
+    let result = this.type_arguments();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsxOpeningElement_attributes<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxOpeningElement::cast_ref(&*this).unwrap();
+    let result = this.attributes();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsxOpeningElement_r_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxOpeningElement::cast_ref(&*this).unwrap();
+    let result = this.r_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxOpeningFragment {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxOpeningFragment,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxOpeningFragment_l_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxOpeningFragment::cast_ref(&*this).unwrap();
+    let result = this.l_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxOpeningFragment_r_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxOpeningFragment::cast_ref(&*this).unwrap();
+    let result = this.r_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxReferenceIdentifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxReferenceIdentifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxReferenceIdentifier_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxReferenceIdentifier::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxSelfClosingElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxSelfClosingElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSelfClosingElement_l_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSelfClosingElement::cast_ref(&*this).unwrap();
+    let result = this.l_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSelfClosingElement_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSelfClosingElement::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSelfClosingElement_type_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSelfClosingElement::cast_ref(&*this).unwrap();
+    let result = this.type_arguments();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSelfClosingElement_attributes<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSelfClosingElement::cast_ref(&*this).unwrap();
+    let result = this.attributes();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsxSelfClosingElement_slash_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSelfClosingElement::cast_ref(&*this).unwrap();
+    let result = this.slash_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSelfClosingElement_r_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSelfClosingElement::cast_ref(&*this).unwrap();
+    let result = this.r_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxSpreadAttribute {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxSpreadAttribute,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSpreadAttribute_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSpreadAttribute::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSpreadAttribute_dotdotdot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSpreadAttribute::cast_ref(&*this).unwrap();
+    let result = this.dotdotdot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSpreadAttribute_argument<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSpreadAttribute::cast_ref(&*this).unwrap();
+    let result = this.argument();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSpreadAttribute_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSpreadAttribute::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxSpreadChild {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxSpreadChild,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSpreadChild_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSpreadChild::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSpreadChild_dotdotdot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSpreadChild::cast_ref(&*this).unwrap();
+    let result = this.dotdotdot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSpreadChild_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSpreadChild::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsxSpreadChild_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxSpreadChild::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxString {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxString,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxString_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxString::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxTagExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxTagExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxTagExpression_tag<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxTagExpression::cast_ref(&*this).unwrap();
+    let result = this.tag();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::JsxText {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::JsxText,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsxText_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::JsxText::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsAbstractModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsAbstractModifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsAbstractModifier_modifier_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAbstractModifier::cast_ref(&*this).unwrap();
+    let result = this.modifier_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsAccessibilityModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsAccessibilityModifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsAccessibilityModifier_modifier_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAccessibilityModifier::cast_ref(&*this).unwrap();
+    let result = this.modifier_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsAnyType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsAnyType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsAnyType_any_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAnyType::cast_ref(&*this).unwrap();
+    let result = this.any_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsArrayType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsArrayType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsArrayType_element_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsArrayType::cast_ref(&*this).unwrap();
+    let result = this.element_type();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsArrayType_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsArrayType::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsArrayType_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsArrayType::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsAsAssignment {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsAsAssignment,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsAsAssignment_assignment<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAsAssignment::cast_ref(&*this).unwrap();
+    let result = this.assignment();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsAsAssignment_as_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAsAssignment::cast_ref(&*this).unwrap();
+    let result = this.as_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsAsAssignment_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAsAssignment::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsAsExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsAsExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsAsExpression_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAsExpression::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsAsExpression_as_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAsExpression::cast_ref(&*this).unwrap();
+    let result = this.as_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsAsExpression_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAsExpression::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsAssertsCondition {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsAssertsCondition,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsAssertsCondition_is_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAssertsCondition::cast_ref(&*this).unwrap();
+    let result = this.is_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsAssertsCondition_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAssertsCondition::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsAssertsReturnType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsAssertsReturnType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsAssertsReturnType_asserts_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAssertsReturnType::cast_ref(&*this).unwrap();
+    let result = this.asserts_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsAssertsReturnType_parameter_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAssertsReturnType::cast_ref(&*this).unwrap();
+    let result = this.parameter_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsAssertsReturnType_predicate<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsAssertsReturnType::cast_ref(&*this).unwrap();
+    let result = this.predicate();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsBigintLiteralType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsBigintLiteralType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsBigintLiteralType_minus_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsBigintLiteralType::cast_ref(&*this).unwrap();
+    let result = this.minus_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsBigintLiteralType_literal_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsBigintLiteralType::cast_ref(&*this).unwrap();
+    let result = this.literal_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsBigintType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsBigintType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsBigintType_bigint_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsBigintType::cast_ref(&*this).unwrap();
+    let result = this.bigint_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsBooleanLiteralType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsBooleanLiteralType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsBooleanLiteralType_literal<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsBooleanLiteralType::cast_ref(&*this).unwrap();
+    let result = this.literal();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsBooleanType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsBooleanType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsBooleanType_boolean_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsBooleanType::cast_ref(&*this).unwrap();
+    let result = this.boolean_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsCallSignatureTypeMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsCallSignatureTypeMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsCallSignatureTypeMember_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsCallSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsCallSignatureTypeMember_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsCallSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsCallSignatureTypeMember_return_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsCallSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.return_type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsCallSignatureTypeMember_separator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsCallSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.separator_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsConditionalType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsConditionalType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsConditionalType_check_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConditionalType::cast_ref(&*this).unwrap();
+    let result = this.check_type();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConditionalType_extends_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConditionalType::cast_ref(&*this).unwrap();
+    let result = this.extends_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConditionalType_extends_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConditionalType::cast_ref(&*this).unwrap();
+    let result = this.extends_type();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConditionalType_question_mark_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConditionalType::cast_ref(&*this).unwrap();
+    let result = this.question_mark_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConditionalType_true_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConditionalType::cast_ref(&*this).unwrap();
+    let result = this.true_type();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConditionalType_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConditionalType::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConditionalType_false_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConditionalType::cast_ref(&*this).unwrap();
+    let result = this.false_type();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsConstModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsConstModifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstModifier_modifier_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstModifier::cast_ref(&*this).unwrap();
+    let result = this.modifier_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsConstructSignatureTypeMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsConstructSignatureTypeMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructSignatureTypeMember_new_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.new_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructSignatureTypeMember_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructSignatureTypeMember_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructSignatureTypeMember_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructSignatureTypeMember_separator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.separator_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsConstructorSignatureClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsConstructorSignatureClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructorSignatureClassMember_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructorSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsConstructorSignatureClassMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructorSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructorSignatureClassMember_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructorSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructorSignatureClassMember_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructorSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsConstructorType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsConstructorType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructorType_abstract_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructorType::cast_ref(&*this).unwrap();
+    let result = this.abstract_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructorType_new_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructorType::cast_ref(&*this).unwrap();
+    let result = this.new_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructorType_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructorType::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructorType_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructorType::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructorType_fat_arrow_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructorType::cast_ref(&*this).unwrap();
+    let result = this.fat_arrow_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsConstructorType_return_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsConstructorType::cast_ref(&*this).unwrap();
+    let result = this.return_type();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsDeclareFunctionDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsDeclareFunctionDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionDeclaration_async_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.async_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionDeclaration_function_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.function_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionDeclaration_id<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.id();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionDeclaration_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionDeclaration_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionDeclaration_return_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.return_type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionDeclaration_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionDeclaration::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsDeclareFunctionExportDefaultDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsDeclareFunctionExportDefaultDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionExportDefaultDeclaration_async_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.async_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionExportDefaultDeclaration_function_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.function_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionExportDefaultDeclaration_id<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.id();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionExportDefaultDeclaration_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionExportDefaultDeclaration_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionExportDefaultDeclaration_return_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.return_type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareFunctionExportDefaultDeclaration_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareFunctionExportDefaultDeclaration::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsDeclareModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsDeclareModifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareModifier_modifier_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareModifier::cast_ref(&*this).unwrap();
+    let result = this.modifier_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsDeclareStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsDeclareStatement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareStatement_declare_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareStatement::cast_ref(&*this).unwrap();
+    let result = this.declare_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsDeclareStatement_declaration<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDeclareStatement::cast_ref(&*this).unwrap();
+    let result = this.declaration();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsDefaultTypeClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsDefaultTypeClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsDefaultTypeClause_eq_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDefaultTypeClause::cast_ref(&*this).unwrap();
+    let result = this.eq_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsDefaultTypeClause_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDefaultTypeClause::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsDefinitePropertyAnnotation {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsDefinitePropertyAnnotation,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsDefinitePropertyAnnotation_excl_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDefinitePropertyAnnotation::cast_ref(&*this).unwrap();
+    let result = this.excl_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsDefinitePropertyAnnotation_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDefinitePropertyAnnotation::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsDefiniteVariableAnnotation {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsDefiniteVariableAnnotation,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsDefiniteVariableAnnotation_excl_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDefiniteVariableAnnotation::cast_ref(&*this).unwrap();
+    let result = this.excl_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsDefiniteVariableAnnotation_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsDefiniteVariableAnnotation::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsEmptyExternalModuleDeclarationBody {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsEmptyExternalModuleDeclarationBody,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsEmptyExternalModuleDeclarationBody_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsEmptyExternalModuleDeclarationBody::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsEnumDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsEnumDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsEnumDeclaration_const_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsEnumDeclaration::cast_ref(&*this).unwrap();
+    let result = this.const_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsEnumDeclaration_enum_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsEnumDeclaration::cast_ref(&*this).unwrap();
+    let result = this.enum_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsEnumDeclaration_id<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsEnumDeclaration::cast_ref(&*this).unwrap();
+    let result = this.id();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsEnumDeclaration_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsEnumDeclaration::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsEnumDeclaration_members<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsEnumDeclaration::cast_ref(&*this).unwrap();
+    let result = this.members();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsEnumDeclaration_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsEnumDeclaration::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsEnumMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsEnumMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsEnumMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsEnumMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsEnumMember_initializer<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsEnumMember::cast_ref(&*this).unwrap();
+    let result = this.initializer();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsExportAsNamespaceClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsExportAsNamespaceClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsExportAsNamespaceClause_as_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExportAsNamespaceClause::cast_ref(&*this).unwrap();
+    let result = this.as_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsExportAsNamespaceClause_namespace_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExportAsNamespaceClause::cast_ref(&*this).unwrap();
+    let result = this.namespace_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsExportAsNamespaceClause_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExportAsNamespaceClause::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsExportAsNamespaceClause_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExportAsNamespaceClause::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsExportAssignmentClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsExportAssignmentClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsExportAssignmentClause_eq_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExportAssignmentClause::cast_ref(&*this).unwrap();
+    let result = this.eq_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsExportAssignmentClause_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExportAssignmentClause::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsExportAssignmentClause_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExportAssignmentClause::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsExportDeclareClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsExportDeclareClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsExportDeclareClause_declare_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExportDeclareClause::cast_ref(&*this).unwrap();
+    let result = this.declare_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsExportDeclareClause_declaration<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExportDeclareClause::cast_ref(&*this).unwrap();
+    let result = this.declaration();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsExtendsClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsExtendsClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsExtendsClause_extends_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExtendsClause::cast_ref(&*this).unwrap();
+    let result = this.extends_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsExtendsClause_types<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExtendsClause::cast_ref(&*this).unwrap();
+    let result = this.types();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsExternalModuleDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsExternalModuleDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsExternalModuleDeclaration_module_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExternalModuleDeclaration::cast_ref(&*this).unwrap();
+    let result = this.module_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsExternalModuleDeclaration_source<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExternalModuleDeclaration::cast_ref(&*this).unwrap();
+    let result = this.source();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsExternalModuleDeclaration_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExternalModuleDeclaration::cast_ref(&*this).unwrap();
+    let result = this.body();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsExternalModuleReference {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsExternalModuleReference,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsExternalModuleReference_require_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExternalModuleReference::cast_ref(&*this).unwrap();
+    let result = this.require_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsExternalModuleReference_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExternalModuleReference::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsExternalModuleReference_source<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExternalModuleReference::cast_ref(&*this).unwrap();
+    let result = this.source();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsExternalModuleReference_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsExternalModuleReference::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsFunctionType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsFunctionType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsFunctionType_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsFunctionType::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsFunctionType_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsFunctionType::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsFunctionType_fat_arrow_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsFunctionType::cast_ref(&*this).unwrap();
+    let result = this.fat_arrow_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsFunctionType_return_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsFunctionType::cast_ref(&*this).unwrap();
+    let result = this.return_type();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsGetterSignatureClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsGetterSignatureClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureClassMember_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureClassMember_get_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.get_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureClassMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureClassMember_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureClassMember_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureClassMember_return_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.return_type();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureClassMember_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsGetterSignatureTypeMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsGetterSignatureTypeMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureTypeMember_get_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.get_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureTypeMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureTypeMember_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureTypeMember_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureTypeMember_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsGetterSignatureTypeMember_separator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGetterSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.separator_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsGlobalDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsGlobalDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsGlobalDeclaration_global_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGlobalDeclaration::cast_ref(&*this).unwrap();
+    let result = this.global_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsGlobalDeclaration_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsGlobalDeclaration::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsIdentifierBinding {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsIdentifierBinding,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsIdentifierBinding_name_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIdentifierBinding::cast_ref(&*this).unwrap();
+    let result = this.name_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsImplementsClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsImplementsClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsImplementsClause_implements_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImplementsClause::cast_ref(&*this).unwrap();
+    let result = this.implements_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsImplementsClause_types<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImplementsClause::cast_ref(&*this).unwrap();
+    let result = this.types();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsImportEqualsDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsImportEqualsDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportEqualsDeclaration_import_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportEqualsDeclaration::cast_ref(&*this).unwrap();
+    let result = this.import_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportEqualsDeclaration_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportEqualsDeclaration::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportEqualsDeclaration_id<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportEqualsDeclaration::cast_ref(&*this).unwrap();
+    let result = this.id();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportEqualsDeclaration_eq_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportEqualsDeclaration::cast_ref(&*this).unwrap();
+    let result = this.eq_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportEqualsDeclaration_module_reference<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportEqualsDeclaration::cast_ref(&*this).unwrap();
+    let result = this.module_reference();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportEqualsDeclaration_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportEqualsDeclaration::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsImportType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsImportType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportType_typeof_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportType::cast_ref(&*this).unwrap();
+    let result = this.typeof_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportType_import_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportType::cast_ref(&*this).unwrap();
+    let result = this.import_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportType_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportType::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportType_argument_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportType::cast_ref(&*this).unwrap();
+    let result = this.argument_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportType_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportType::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportType_qualifier_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportType::cast_ref(&*this).unwrap();
+    let result = this.qualifier_clause();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportType_type_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportType::cast_ref(&*this).unwrap();
+    let result = this.type_arguments();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsImportTypeQualifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsImportTypeQualifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportTypeQualifier_dot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportTypeQualifier::cast_ref(&*this).unwrap();
+    let result = this.dot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsImportTypeQualifier_right<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsImportTypeQualifier::cast_ref(&*this).unwrap();
+    let result = this.right();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsInModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsInModifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsInModifier_modifier_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInModifier::cast_ref(&*this).unwrap();
+    let result = this.modifier_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsIndexSignatureClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsIndexSignatureClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureClassMember_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureClassMember_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureClassMember_parameter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.parameter();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureClassMember_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureClassMember_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureClassMember_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsIndexSignatureParameter {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsIndexSignatureParameter,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureParameter_binding<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureParameter::cast_ref(&*this).unwrap();
+    let result = this.binding();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureParameter_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureParameter::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsIndexSignatureTypeMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsIndexSignatureTypeMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureTypeMember_readonly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.readonly_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureTypeMember_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureTypeMember_parameter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.parameter();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureTypeMember_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureTypeMember_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexSignatureTypeMember_separator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.separator_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsIndexedAccessType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsIndexedAccessType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexedAccessType_object_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexedAccessType::cast_ref(&*this).unwrap();
+    let result = this.object_type();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexedAccessType_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexedAccessType::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexedAccessType_index_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexedAccessType::cast_ref(&*this).unwrap();
+    let result = this.index_type();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsIndexedAccessType_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIndexedAccessType::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsInferType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsInferType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsInferType_infer_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInferType::cast_ref(&*this).unwrap();
+    let result = this.infer_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsInferType_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInferType::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsInferType_constraint<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInferType::cast_ref(&*this).unwrap();
+    let result = this.constraint();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsInitializedPropertySignatureClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsInitializedPropertySignatureClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsInitializedPropertySignatureClassMember_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInitializedPropertySignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsInitializedPropertySignatureClassMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInitializedPropertySignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsInitializedPropertySignatureClassMember_question_mark_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInitializedPropertySignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.question_mark_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsInitializedPropertySignatureClassMember_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInitializedPropertySignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsInitializedPropertySignatureClassMember_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInitializedPropertySignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsInstantiationExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsInstantiationExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsInstantiationExpression_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInstantiationExpression::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsInstantiationExpression_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInstantiationExpression::cast_ref(&*this).unwrap();
+    let result = this.arguments();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsInterfaceDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsInterfaceDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsInterfaceDeclaration_interface_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInterfaceDeclaration::cast_ref(&*this).unwrap();
+    let result = this.interface_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsInterfaceDeclaration_id<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInterfaceDeclaration::cast_ref(&*this).unwrap();
+    let result = this.id();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsInterfaceDeclaration_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInterfaceDeclaration::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsInterfaceDeclaration_extends_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInterfaceDeclaration::cast_ref(&*this).unwrap();
+    let result = this.extends_clause();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsInterfaceDeclaration_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInterfaceDeclaration::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsInterfaceDeclaration_members<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInterfaceDeclaration::cast_ref(&*this).unwrap();
+    let result = this.members();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsInterfaceDeclaration_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsInterfaceDeclaration::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsIntersectionType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsIntersectionType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsIntersectionType_leading_separator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIntersectionType::cast_ref(&*this).unwrap();
+    let result = this.leading_separator_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsIntersectionType_types<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsIntersectionType::cast_ref(&*this).unwrap();
+    let result = this.types();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsMappedType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsMappedType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedType_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedType::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedType_readonly_modifier<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedType::cast_ref(&*this).unwrap();
+    let result = this.readonly_modifier();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedType_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedType::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedType_property_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedType::cast_ref(&*this).unwrap();
+    let result = this.property_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedType_in_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedType::cast_ref(&*this).unwrap();
+    let result = this.in_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedType_keys_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedType::cast_ref(&*this).unwrap();
+    let result = this.keys_type();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedType_as_clause<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedType::cast_ref(&*this).unwrap();
+    let result = this.as_clause();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedType_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedType::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedType_optional_modifier<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedType::cast_ref(&*this).unwrap();
+    let result = this.optional_modifier();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedType_mapped_type<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedType::cast_ref(&*this).unwrap();
+    let result = this.mapped_type();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedType_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedType::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedType_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedType::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsMappedTypeAsClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsMappedTypeAsClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedTypeAsClause_as_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedTypeAsClause::cast_ref(&*this).unwrap();
+    let result = this.as_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedTypeAsClause_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedTypeAsClause::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsMappedTypeOptionalModifierClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsMappedTypeOptionalModifierClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedTypeOptionalModifierClause_operator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedTypeOptionalModifierClause::cast_ref(&*this).unwrap();
+    let result = this.operator_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedTypeOptionalModifierClause_question_mark_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedTypeOptionalModifierClause::cast_ref(&*this).unwrap();
+    let result = this.question_mark_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsMappedTypeReadonlyModifierClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsMappedTypeReadonlyModifierClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedTypeReadonlyModifierClause_operator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedTypeReadonlyModifierClause::cast_ref(&*this).unwrap();
+    let result = this.operator_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMappedTypeReadonlyModifierClause_readonly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMappedTypeReadonlyModifierClause::cast_ref(&*this).unwrap();
+    let result = this.readonly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsMethodSignatureClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsMethodSignatureClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureClassMember_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureClassMember_async_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.async_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureClassMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureClassMember_question_mark_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.question_mark_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureClassMember_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureClassMember_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureClassMember_return_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.return_type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureClassMember_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsMethodSignatureTypeMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsMethodSignatureTypeMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureTypeMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureTypeMember_optional_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.optional_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureTypeMember_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureTypeMember_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.parameters();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureTypeMember_return_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.return_type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsMethodSignatureTypeMember_separator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsMethodSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.separator_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsModuleBlock {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsModuleBlock,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsModuleBlock_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsModuleBlock::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsModuleBlock_items<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsModuleBlock::cast_ref(&*this).unwrap();
+    let result = this.items();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsModuleBlock_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsModuleBlock::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsModuleDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsModuleDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsModuleDeclaration_module_or_namespace<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsModuleDeclaration::cast_ref(&*this).unwrap();
+    let result = this.module_or_namespace();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsModuleDeclaration_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsModuleDeclaration::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsModuleDeclaration_body<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsModuleDeclaration::cast_ref(&*this).unwrap();
+    let result = this.body();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsNameWithTypeArguments {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsNameWithTypeArguments,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsNameWithTypeArguments_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNameWithTypeArguments::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsNameWithTypeArguments_type_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNameWithTypeArguments::cast_ref(&*this).unwrap();
+    let result = this.type_arguments();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsNamedTupleTypeElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsNamedTupleTypeElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsNamedTupleTypeElement_dotdotdot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNamedTupleTypeElement::cast_ref(&*this).unwrap();
+    let result = this.dotdotdot_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsNamedTupleTypeElement_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNamedTupleTypeElement::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsNamedTupleTypeElement_question_mark_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNamedTupleTypeElement::cast_ref(&*this).unwrap();
+    let result = this.question_mark_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsNamedTupleTypeElement_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNamedTupleTypeElement::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsNamedTupleTypeElement_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNamedTupleTypeElement::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsNeverType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsNeverType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsNeverType_never_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNeverType::cast_ref(&*this).unwrap();
+    let result = this.never_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsNonNullAssertionAssignment {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsNonNullAssertionAssignment,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsNonNullAssertionAssignment_assignment<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNonNullAssertionAssignment::cast_ref(&*this).unwrap();
+    let result = this.assignment();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsNonNullAssertionAssignment_excl_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNonNullAssertionAssignment::cast_ref(&*this).unwrap();
+    let result = this.excl_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsNonNullAssertionExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsNonNullAssertionExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsNonNullAssertionExpression_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNonNullAssertionExpression::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsNonNullAssertionExpression_excl_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNonNullAssertionExpression::cast_ref(&*this).unwrap();
+    let result = this.excl_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsNonPrimitiveType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsNonPrimitiveType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsNonPrimitiveType_object_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNonPrimitiveType::cast_ref(&*this).unwrap();
+    let result = this.object_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsNullLiteralType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsNullLiteralType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsNullLiteralType_literal_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNullLiteralType::cast_ref(&*this).unwrap();
+    let result = this.literal_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsNumberLiteralType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsNumberLiteralType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsNumberLiteralType_minus_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNumberLiteralType::cast_ref(&*this).unwrap();
+    let result = this.minus_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsNumberLiteralType_literal_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNumberLiteralType::cast_ref(&*this).unwrap();
+    let result = this.literal_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsNumberType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsNumberType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsNumberType_number_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsNumberType::cast_ref(&*this).unwrap();
+    let result = this.number_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsObjectType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsObjectType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsObjectType_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsObjectType::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsObjectType_members<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsObjectType::cast_ref(&*this).unwrap();
+    let result = this.members();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsObjectType_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsObjectType::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsOptionalPropertyAnnotation {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsOptionalPropertyAnnotation,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsOptionalPropertyAnnotation_question_mark_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsOptionalPropertyAnnotation::cast_ref(&*this).unwrap();
+    let result = this.question_mark_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsOptionalPropertyAnnotation_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsOptionalPropertyAnnotation::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsOptionalTupleTypeElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsOptionalTupleTypeElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsOptionalTupleTypeElement_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsOptionalTupleTypeElement::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsOptionalTupleTypeElement_question_mark_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsOptionalTupleTypeElement::cast_ref(&*this).unwrap();
+    let result = this.question_mark_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsOutModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsOutModifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsOutModifier_modifier_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsOutModifier::cast_ref(&*this).unwrap();
+    let result = this.modifier_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsOverrideModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsOverrideModifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsOverrideModifier_modifier_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsOverrideModifier::cast_ref(&*this).unwrap();
+    let result = this.modifier_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsParenthesizedType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsParenthesizedType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsParenthesizedType_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsParenthesizedType::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsParenthesizedType_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsParenthesizedType::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsParenthesizedType_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsParenthesizedType::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsPredicateReturnType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsPredicateReturnType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsPredicateReturnType_parameter_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPredicateReturnType::cast_ref(&*this).unwrap();
+    let result = this.parameter_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsPredicateReturnType_is_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPredicateReturnType::cast_ref(&*this).unwrap();
+    let result = this.is_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsPredicateReturnType_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPredicateReturnType::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsPropertyParameter {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsPropertyParameter,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsPropertyParameter_decorators<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPropertyParameter::cast_ref(&*this).unwrap();
+    let result = this.decorators();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsPropertyParameter_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPropertyParameter::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsPropertyParameter_formal_parameter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPropertyParameter::cast_ref(&*this).unwrap();
+    let result = this.formal_parameter();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsPropertySignatureClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsPropertySignatureClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsPropertySignatureClassMember_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPropertySignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsPropertySignatureClassMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPropertySignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsPropertySignatureClassMember_property_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPropertySignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.property_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsPropertySignatureClassMember_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPropertySignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsPropertySignatureTypeMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsPropertySignatureTypeMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsPropertySignatureTypeMember_readonly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPropertySignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.readonly_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsPropertySignatureTypeMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPropertySignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsPropertySignatureTypeMember_optional_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPropertySignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.optional_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsPropertySignatureTypeMember_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPropertySignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsPropertySignatureTypeMember_separator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsPropertySignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.separator_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsQualifiedModuleName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsQualifiedModuleName,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsQualifiedModuleName_left<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsQualifiedModuleName::cast_ref(&*this).unwrap();
+    let result = this.left();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsQualifiedModuleName_dot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsQualifiedModuleName::cast_ref(&*this).unwrap();
+    let result = this.dot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsQualifiedModuleName_right<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsQualifiedModuleName::cast_ref(&*this).unwrap();
+    let result = this.right();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsQualifiedName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsQualifiedName,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsQualifiedName_left<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsQualifiedName::cast_ref(&*this).unwrap();
+    let result = this.left();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsQualifiedName_dot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsQualifiedName::cast_ref(&*this).unwrap();
+    let result = this.dot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsQualifiedName_right<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsQualifiedName::cast_ref(&*this).unwrap();
+    let result = this.right();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsReadonlyModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsReadonlyModifier,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsReadonlyModifier_modifier_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsReadonlyModifier::cast_ref(&*this).unwrap();
+    let result = this.modifier_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsReferenceType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsReferenceType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsReferenceType_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsReferenceType::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsReferenceType_type_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsReferenceType::cast_ref(&*this).unwrap();
+    let result = this.type_arguments();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsRestTupleTypeElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsRestTupleTypeElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsRestTupleTypeElement_dotdotdot_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsRestTupleTypeElement::cast_ref(&*this).unwrap();
+    let result = this.dotdotdot_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsRestTupleTypeElement_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsRestTupleTypeElement::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsReturnTypeAnnotation {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsReturnTypeAnnotation,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsReturnTypeAnnotation_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsReturnTypeAnnotation::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsReturnTypeAnnotation_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsReturnTypeAnnotation::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsSatisfiesAssignment {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsSatisfiesAssignment,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsSatisfiesAssignment_assignment<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSatisfiesAssignment::cast_ref(&*this).unwrap();
+    let result = this.assignment();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSatisfiesAssignment_satisfies_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSatisfiesAssignment::cast_ref(&*this).unwrap();
+    let result = this.satisfies_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSatisfiesAssignment_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSatisfiesAssignment::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsSatisfiesExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsSatisfiesExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsSatisfiesExpression_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSatisfiesExpression::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSatisfiesExpression_satisfies_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSatisfiesExpression::cast_ref(&*this).unwrap();
+    let result = this.satisfies_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSatisfiesExpression_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSatisfiesExpression::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsSetterSignatureClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsSetterSignatureClassMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureClassMember_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureClassMember_set_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.set_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureClassMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureClassMember_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureClassMember_parameter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.parameter();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureClassMember_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureClassMember_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureClassMember::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsSetterSignatureTypeMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsSetterSignatureTypeMember,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureTypeMember_set_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.set_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureTypeMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureTypeMember_l_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.l_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureTypeMember_parameter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.parameter();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureTypeMember_r_paren_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.r_paren_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsSetterSignatureTypeMember_separator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSetterSignatureTypeMember::cast_ref(&*this).unwrap();
+    let result = this.separator_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsStringLiteralType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsStringLiteralType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsStringLiteralType_literal_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsStringLiteralType::cast_ref(&*this).unwrap();
+    let result = this.literal_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsStringType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsStringType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsStringType_string_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsStringType::cast_ref(&*this).unwrap();
+    let result = this.string_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsSymbolType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsSymbolType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsSymbolType_symbol_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsSymbolType::cast_ref(&*this).unwrap();
+    let result = this.symbol_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTemplateChunkElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTemplateChunkElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTemplateChunkElement_template_chunk_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTemplateChunkElement::cast_ref(&*this).unwrap();
+    let result = this.template_chunk_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTemplateElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTemplateElement,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTemplateElement_dollar_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTemplateElement::cast_ref(&*this).unwrap();
+    let result = this.dollar_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTemplateElement_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTemplateElement::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTemplateElement_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTemplateElement::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTemplateLiteralType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTemplateLiteralType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTemplateLiteralType_l_tick_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTemplateLiteralType::cast_ref(&*this).unwrap();
+    let result = this.l_tick_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTemplateLiteralType_elements<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTemplateLiteralType::cast_ref(&*this).unwrap();
+    let result = this.elements();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsTemplateLiteralType_r_tick_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTemplateLiteralType::cast_ref(&*this).unwrap();
+    let result = this.r_tick_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsThisParameter {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsThisParameter,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsThisParameter_this_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsThisParameter::cast_ref(&*this).unwrap();
+    let result = this.this_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsThisParameter_type_annotation<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsThisParameter::cast_ref(&*this).unwrap();
+    let result = this.type_annotation();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsThisType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsThisType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsThisType_this_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsThisType::cast_ref(&*this).unwrap();
+    let result = this.this_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTupleType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTupleType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTupleType_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTupleType::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTupleType_elements<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTupleType::cast_ref(&*this).unwrap();
+    let result = this.elements();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsTupleType_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTupleType::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTypeAliasDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTypeAliasDeclaration,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAliasDeclaration_type_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAliasDeclaration::cast_ref(&*this).unwrap();
+    let result = this.type_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAliasDeclaration_binding_identifier<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAliasDeclaration::cast_ref(&*this).unwrap();
+    let result = this.binding_identifier();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAliasDeclaration_type_parameters<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAliasDeclaration::cast_ref(&*this).unwrap();
+    let result = this.type_parameters();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAliasDeclaration_eq_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAliasDeclaration::cast_ref(&*this).unwrap();
+    let result = this.eq_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAliasDeclaration_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAliasDeclaration::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAliasDeclaration_semicolon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAliasDeclaration::cast_ref(&*this).unwrap();
+    let result = this.semicolon_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTypeAnnotation {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTypeAnnotation,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAnnotation_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAnnotation::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAnnotation_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAnnotation::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTypeArguments {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTypeArguments,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeArguments_l_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeArguments::cast_ref(&*this).unwrap();
+    let result = this.l_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeArguments_ts_type_argument_list<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeArguments::cast_ref(&*this).unwrap();
+    let result = this.ts_type_argument_list();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsTypeArguments_r_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeArguments::cast_ref(&*this).unwrap();
+    let result = this.r_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTypeAssertionAssignment {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTypeAssertionAssignment,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAssertionAssignment_l_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAssertionAssignment::cast_ref(&*this).unwrap();
+    let result = this.l_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAssertionAssignment_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAssertionAssignment::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAssertionAssignment_r_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAssertionAssignment::cast_ref(&*this).unwrap();
+    let result = this.r_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAssertionAssignment_assignment<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAssertionAssignment::cast_ref(&*this).unwrap();
+    let result = this.assignment();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTypeAssertionExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTypeAssertionExpression,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAssertionExpression_l_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAssertionExpression::cast_ref(&*this).unwrap();
+    let result = this.l_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAssertionExpression_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAssertionExpression::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAssertionExpression_r_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAssertionExpression::cast_ref(&*this).unwrap();
+    let result = this.r_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeAssertionExpression_expression<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeAssertionExpression::cast_ref(&*this).unwrap();
+    let result = this.expression();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTypeConstraintClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTypeConstraintClause,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeConstraintClause_extends_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeConstraintClause::cast_ref(&*this).unwrap();
+    let result = this.extends_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeConstraintClause_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeConstraintClause::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTypeOperatorType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTypeOperatorType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeOperatorType_operator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeOperatorType::cast_ref(&*this).unwrap();
+    let result = this.operator_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeOperatorType_ty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeOperatorType::cast_ref(&*this).unwrap();
+    let result = this.ty();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTypeParameter {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTypeParameter,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeParameter_modifiers<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeParameter::cast_ref(&*this).unwrap();
+    let result = this.modifiers();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsTypeParameter_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeParameter::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeParameter_constraint<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeParameter::cast_ref(&*this).unwrap();
+    let result = this.constraint();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeParameter_default<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeParameter::cast_ref(&*this).unwrap();
+    let result = this.default();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTypeParameterName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTypeParameterName,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeParameterName_ident_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeParameterName::cast_ref(&*this).unwrap();
+    let result = this.ident_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTypeParameters {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTypeParameters,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeParameters_l_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeParameters::cast_ref(&*this).unwrap();
+    let result = this.l_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeParameters_items<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeParameters::cast_ref(&*this).unwrap();
+    let result = this.items();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn TsTypeParameters_r_angle_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeParameters::cast_ref(&*this).unwrap();
+    let result = this.r_angle_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsTypeofType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsTypeofType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeofType_typeof_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeofType::cast_ref(&*this).unwrap();
+    let result = this.typeof_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeofType_expression_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeofType::cast_ref(&*this).unwrap();
+    let result = this.expression_name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn TsTypeofType_type_arguments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsTypeofType::cast_ref(&*this).unwrap();
+    let result = this.type_arguments();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsUndefinedType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsUndefinedType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsUndefinedType_undefined_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsUndefinedType::cast_ref(&*this).unwrap();
+    let result = this.undefined_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsUnionType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsUnionType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsUnionType_leading_separator_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsUnionType::cast_ref(&*this).unwrap();
+    let result = this.leading_separator_token();
+    if let Some(result) = result {
+        let result = ToV8::to_v8(result, scope).unwrap();
+        res.set(result);
+    } else {
+        res.set_undefined();
+    }
+}
+#[allow(non_snake_case)]
+fn TsUnionType_types<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsUnionType::cast_ref(&*this).unwrap();
+    let result = this.types();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsUnknownType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsUnknownType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsUnknownType_unknown_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsUnknownType::cast_ref(&*this).unwrap();
+    let result = this.unknown_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::TsVoidType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_js_syntax::TsVoidType,
+            rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn TsVoidType_void_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_rowan::SyntaxNode<rome_js_syntax::JsLanguage>>::from_v8(scope, this)
+            .unwrap();
+    let this = rome_js_syntax::TsVoidType::cast_ref(&*this).unwrap();
+    let result = this.void_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsArrayAssignmentPatternElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsAssignmentPattern(node) => ToV8::to_v8(node, scope),
+            Self::JsArrayAssignmentPatternRestElement(node) => ToV8::to_v8(node, scope),
+            Self::JsArrayHole(node) => ToV8::to_v8(node, scope),
+            Self::JsAssignmentWithDefault(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsArrayBindingPatternElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsBindingPattern(node) => ToV8::to_v8(node, scope),
+            Self::JsArrayBindingPatternRestElement(node) => ToV8::to_v8(node, scope),
+            Self::JsArrayHole(node) => ToV8::to_v8(node, scope),
+            Self::JsBindingPatternWithDefault(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsArrayElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsArrayHole(node) => ToV8::to_v8(node, scope),
+            Self::JsSpread(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsArrowFunctionParameters {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsBinding(node) => ToV8::to_v8(node, scope),
+            Self::JsParameters(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsAssignment {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBogusAssignment(node) => ToV8::to_v8(node, scope),
+            Self::JsComputedMemberAssignment(node) => ToV8::to_v8(node, scope),
+            Self::JsIdentifierAssignment(node) => ToV8::to_v8(node, scope),
+            Self::JsParenthesizedAssignment(node) => ToV8::to_v8(node, scope),
+            Self::JsStaticMemberAssignment(node) => ToV8::to_v8(node, scope),
+            Self::TsAsAssignment(node) => ToV8::to_v8(node, scope),
+            Self::TsNonNullAssertionAssignment(node) => ToV8::to_v8(node, scope),
+            Self::TsSatisfiesAssignment(node) => ToV8::to_v8(node, scope),
+            Self::TsTypeAssertionAssignment(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsAssignmentPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsAssignment(node) => ToV8::to_v8(node, scope),
+            Self::JsArrayAssignmentPattern(node) => ToV8::to_v8(node, scope),
+            Self::JsObjectAssignmentPattern(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsBinding {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBogusBinding(node) => ToV8::to_v8(node, scope),
+            Self::JsIdentifierBinding(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsBindingPattern {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsBinding(node) => ToV8::to_v8(node, scope),
+            Self::JsArrayBindingPattern(node) => ToV8::to_v8(node, scope),
+            Self::JsObjectBindingPattern(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsCallArgument {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsSpread(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsClass {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsClassDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::JsClassExportDefaultDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::JsClassExpression(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsClassMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBogusMember(node) => ToV8::to_v8(node, scope),
+            Self::JsConstructorClassMember(node) => ToV8::to_v8(node, scope),
+            Self::JsEmptyClassMember(node) => ToV8::to_v8(node, scope),
+            Self::JsGetterClassMember(node) => ToV8::to_v8(node, scope),
+            Self::JsMethodClassMember(node) => ToV8::to_v8(node, scope),
+            Self::JsPropertyClassMember(node) => ToV8::to_v8(node, scope),
+            Self::JsSetterClassMember(node) => ToV8::to_v8(node, scope),
+            Self::JsStaticInitializationBlockClassMember(node) => ToV8::to_v8(node, scope),
+            Self::TsConstructorSignatureClassMember(node) => ToV8::to_v8(node, scope),
+            Self::TsGetterSignatureClassMember(node) => ToV8::to_v8(node, scope),
+            Self::TsIndexSignatureClassMember(node) => ToV8::to_v8(node, scope),
+            Self::TsInitializedPropertySignatureClassMember(node) => ToV8::to_v8(node, scope),
+            Self::TsMethodSignatureClassMember(node) => ToV8::to_v8(node, scope),
+            Self::TsPropertySignatureClassMember(node) => ToV8::to_v8(node, scope),
+            Self::TsSetterSignatureClassMember(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsClassMemberName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsComputedMemberName(node) => ToV8::to_v8(node, scope),
+            Self::JsLiteralMemberName(node) => ToV8::to_v8(node, scope),
+            Self::JsPrivateClassMemberName(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsConstructorParameter {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsFormalParameter(node) => ToV8::to_v8(node, scope),
+            Self::JsRestParameter(node) => ToV8::to_v8(node, scope),
+            Self::TsPropertyParameter(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsClassDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::JsFunctionDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::JsVariableDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsDeclareFunctionDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsEnumDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsExternalModuleDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsGlobalDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsImportEqualsDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsInterfaceDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsModuleDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsTypeAliasDeclaration(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsDeclarationClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsClassDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::JsFunctionDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::JsVariableDeclarationClause(node) => ToV8::to_v8(node, scope),
+            Self::TsDeclareFunctionDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsEnumDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsExternalModuleDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsGlobalDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsImportEqualsDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsInterfaceDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsModuleDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsTypeAliasDeclaration(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsDecorator {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBogusExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsCallExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsIdentifierExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsParenthesizedExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsStaticMemberExpression(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsExportClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsDeclarationClause(node) => ToV8::to_v8(node, scope),
+            Self::JsExportDefaultDeclarationClause(node) => ToV8::to_v8(node, scope),
+            Self::JsExportDefaultExpressionClause(node) => ToV8::to_v8(node, scope),
+            Self::JsExportFromClause(node) => ToV8::to_v8(node, scope),
+            Self::JsExportNamedClause(node) => ToV8::to_v8(node, scope),
+            Self::JsExportNamedFromClause(node) => ToV8::to_v8(node, scope),
+            Self::TsExportAsNamespaceClause(node) => ToV8::to_v8(node, scope),
+            Self::TsExportAssignmentClause(node) => ToV8::to_v8(node, scope),
+            Self::TsExportDeclareClause(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsExportDefaultDeclaration {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsClassExportDefaultDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::JsFunctionExportDefaultDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsDeclareFunctionExportDefaultDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsInterfaceDeclaration(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsExportNamedSpecifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsExportNamedShorthandSpecifier(node) => ToV8::to_v8(node, scope),
+            Self::JsExportNamedSpecifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsLiteralExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsArrayExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsArrowFunctionExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsAssignmentExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsAwaitExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsBinaryExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsBogusExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsCallExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsClassExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsComputedMemberExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsConditionalExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsFunctionExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsIdentifierExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsImportCallExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsImportMetaExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsInExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsInstanceofExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsLogicalExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsNewExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsNewTargetExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsObjectExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsParenthesizedExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsPostUpdateExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsPreUpdateExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsSequenceExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsStaticMemberExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsSuperExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsTemplateExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsThisExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsUnaryExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsYieldExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsxTagExpression(node) => ToV8::to_v8(node, scope),
+            Self::TsAsExpression(node) => ToV8::to_v8(node, scope),
+            Self::TsInstantiationExpression(node) => ToV8::to_v8(node, scope),
+            Self::TsNonNullAssertionExpression(node) => ToV8::to_v8(node, scope),
+            Self::TsSatisfiesExpression(node) => ToV8::to_v8(node, scope),
+            Self::TsTypeAssertionExpression(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsForInOrOfInitializer {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsAssignmentPattern(node) => ToV8::to_v8(node, scope),
+            Self::JsForVariableDeclaration(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsForInitializer {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsVariableDeclaration(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsFormalParameter {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBogusParameter(node) => ToV8::to_v8(node, scope),
+            Self::JsFormalParameter(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsFunction {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsArrowFunctionExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsFunctionDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::JsFunctionExportDefaultDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::JsFunctionExpression(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsFunctionBody {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsFunctionBody(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsImportAssertionEntry {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBogusImportAssertionEntry(node) => ToV8::to_v8(node, scope),
+            Self::JsImportAssertionEntry(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsImportClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsImportBareClause(node) => ToV8::to_v8(node, scope),
+            Self::JsImportDefaultClause(node) => ToV8::to_v8(node, scope),
+            Self::JsImportNamedClause(node) => ToV8::to_v8(node, scope),
+            Self::JsImportNamespaceClause(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsInProperty {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsPrivateName(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsLiteralExpression {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBigintLiteralExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsBooleanLiteralExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsNullLiteralExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsNumberLiteralExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsRegexLiteralExpression(node) => ToV8::to_v8(node, scope),
+            Self::JsStringLiteralExpression(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsMethodModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsDecorator(node) => ToV8::to_v8(node, scope),
+            Self::JsStaticModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsAccessibilityModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsOverrideModifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsModuleItem {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsExport(node) => ToV8::to_v8(node, scope),
+            Self::JsImport(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsName(node) => ToV8::to_v8(node, scope),
+            Self::JsPrivateName(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsNamedImport {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsNamedImportSpecifiers(node) => ToV8::to_v8(node, scope),
+            Self::JsNamespaceImportSpecifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsNamedImportSpecifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBogusNamedImportSpecifier(node) => ToV8::to_v8(node, scope),
+            Self::JsNamedImportSpecifier(node) => ToV8::to_v8(node, scope),
+            Self::JsShorthandNamedImportSpecifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsObjectAssignmentPatternMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBogusAssignment(node) => ToV8::to_v8(node, scope),
+            Self::JsObjectAssignmentPatternProperty(node) => ToV8::to_v8(node, scope),
+            Self::JsObjectAssignmentPatternRest(node) => ToV8::to_v8(node, scope),
+            Self::JsObjectAssignmentPatternShorthandProperty(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsObjectBindingPatternMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBogusBinding(node) => ToV8::to_v8(node, scope),
+            Self::JsObjectBindingPatternProperty(node) => ToV8::to_v8(node, scope),
+            Self::JsObjectBindingPatternRest(node) => ToV8::to_v8(node, scope),
+            Self::JsObjectBindingPatternShorthandProperty(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsObjectMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBogusMember(node) => ToV8::to_v8(node, scope),
+            Self::JsGetterObjectMember(node) => ToV8::to_v8(node, scope),
+            Self::JsMethodObjectMember(node) => ToV8::to_v8(node, scope),
+            Self::JsPropertyObjectMember(node) => ToV8::to_v8(node, scope),
+            Self::JsSetterObjectMember(node) => ToV8::to_v8(node, scope),
+            Self::JsShorthandPropertyObjectMember(node) => ToV8::to_v8(node, scope),
+            Self::JsSpread(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsObjectMemberName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsComputedMemberName(node) => ToV8::to_v8(node, scope),
+            Self::JsLiteralMemberName(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsParameter {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsFormalParameter(node) => ToV8::to_v8(node, scope),
+            Self::JsRestParameter(node) => ToV8::to_v8(node, scope),
+            Self::TsThisParameter(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsPropertyModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsAccessorModifier(node) => ToV8::to_v8(node, scope),
+            Self::JsDecorator(node) => ToV8::to_v8(node, scope),
+            Self::JsStaticModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsAccessibilityModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsOverrideModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsReadonlyModifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsRoot {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsExpressionSnipped(node) => ToV8::to_v8(node, scope),
+            Self::JsModule(node) => ToV8::to_v8(node, scope),
+            Self::JsScript(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsStatement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBlockStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsBogusStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsBreakStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsClassDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::JsContinueStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsDebuggerStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsDoWhileStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsEmptyStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsExpressionStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsForInStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsForOfStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsForStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsFunctionDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::JsIfStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsLabeledStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsReturnStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsSwitchStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsThrowStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsTryFinallyStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsTryStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsVariableStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsWhileStatement(node) => ToV8::to_v8(node, scope),
+            Self::JsWithStatement(node) => ToV8::to_v8(node, scope),
+            Self::TsDeclareFunctionDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsDeclareStatement(node) => ToV8::to_v8(node, scope),
+            Self::TsEnumDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsExternalModuleDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsGlobalDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsImportEqualsDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsInterfaceDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsModuleDeclaration(node) => ToV8::to_v8(node, scope),
+            Self::TsTypeAliasDeclaration(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsSwitchClause {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsCaseClause(node) => ToV8::to_v8(node, scope),
+            Self::JsDefaultClause(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsTemplateElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsTemplateChunkElement(node) => ToV8::to_v8(node, scope),
+            Self::JsTemplateElement(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsxAttribute {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsxAttribute(node) => ToV8::to_v8(node, scope),
+            Self::JsxSpreadAttribute(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsxAttributeName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsxName(node) => ToV8::to_v8(node, scope),
+            Self::JsxNamespaceName(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsxAttributeValue {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyJsxTag(node) => ToV8::to_v8(node, scope),
+            Self::JsxExpressionAttributeValue(node) => ToV8::to_v8(node, scope),
+            Self::JsxString(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsxChild {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsxElement(node) => ToV8::to_v8(node, scope),
+            Self::JsxExpressionChild(node) => ToV8::to_v8(node, scope),
+            Self::JsxFragment(node) => ToV8::to_v8(node, scope),
+            Self::JsxSelfClosingElement(node) => ToV8::to_v8(node, scope),
+            Self::JsxSpreadChild(node) => ToV8::to_v8(node, scope),
+            Self::JsxText(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsxElementName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsxMemberName(node) => ToV8::to_v8(node, scope),
+            Self::JsxName(node) => ToV8::to_v8(node, scope),
+            Self::JsxNamespaceName(node) => ToV8::to_v8(node, scope),
+            Self::JsxReferenceIdentifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsxName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsxName(node) => ToV8::to_v8(node, scope),
+            Self::JsxNamespaceName(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsxObjectName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsxMemberName(node) => ToV8::to_v8(node, scope),
+            Self::JsxNamespaceName(node) => ToV8::to_v8(node, scope),
+            Self::JsxReferenceIdentifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyJsxTag {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsxElement(node) => ToV8::to_v8(node, scope),
+            Self::JsxFragment(node) => ToV8::to_v8(node, scope),
+            Self::JsxSelfClosingElement(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsExternalModuleDeclarationBody {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::TsEmptyExternalModuleDeclarationBody(node) => ToV8::to_v8(node, scope),
+            Self::TsModuleBlock(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsIndexSignatureModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsStaticModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsReadonlyModifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsMethodSignatureModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsDecorator(node) => ToV8::to_v8(node, scope),
+            Self::JsStaticModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsAbstractModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsAccessibilityModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsOverrideModifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsModuleName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::TsIdentifierBinding(node) => ToV8::to_v8(node, scope),
+            Self::TsQualifiedModuleName(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsModuleReference {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyTsName(node) => ToV8::to_v8(node, scope),
+            Self::TsExternalModuleReference(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsReferenceIdentifier(node) => ToV8::to_v8(node, scope),
+            Self::TsQualifiedName(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsPropertyAnnotation {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::TsDefinitePropertyAnnotation(node) => ToV8::to_v8(node, scope),
+            Self::TsOptionalPropertyAnnotation(node) => ToV8::to_v8(node, scope),
+            Self::TsTypeAnnotation(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsPropertyParameterModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::TsAccessibilityModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsOverrideModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsReadonlyModifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsPropertySignatureAnnotation {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::TsOptionalPropertyAnnotation(node) => ToV8::to_v8(node, scope),
+            Self::TsTypeAnnotation(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsPropertySignatureModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsAccessorModifier(node) => ToV8::to_v8(node, scope),
+            Self::JsDecorator(node) => ToV8::to_v8(node, scope),
+            Self::JsStaticModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsAbstractModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsAccessibilityModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsDeclareModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsOverrideModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsReadonlyModifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsReturnType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyTsType(node) => ToV8::to_v8(node, scope),
+            Self::TsAssertsReturnType(node) => ToV8::to_v8(node, scope),
+            Self::TsPredicateReturnType(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsTemplateElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::TsTemplateChunkElement(node) => ToV8::to_v8(node, scope),
+            Self::TsTemplateElement(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsTupleTypeElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::AnyTsType(node) => ToV8::to_v8(node, scope),
+            Self::TsNamedTupleTypeElement(node) => ToV8::to_v8(node, scope),
+            Self::TsOptionalTupleTypeElement(node) => ToV8::to_v8(node, scope),
+            Self::TsRestTupleTypeElement(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsType {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::TsAnyType(node) => ToV8::to_v8(node, scope),
+            Self::TsArrayType(node) => ToV8::to_v8(node, scope),
+            Self::TsBigintLiteralType(node) => ToV8::to_v8(node, scope),
+            Self::TsBigintType(node) => ToV8::to_v8(node, scope),
+            Self::TsBogusType(node) => ToV8::to_v8(node, scope),
+            Self::TsBooleanLiteralType(node) => ToV8::to_v8(node, scope),
+            Self::TsBooleanType(node) => ToV8::to_v8(node, scope),
+            Self::TsConditionalType(node) => ToV8::to_v8(node, scope),
+            Self::TsConstructorType(node) => ToV8::to_v8(node, scope),
+            Self::TsFunctionType(node) => ToV8::to_v8(node, scope),
+            Self::TsImportType(node) => ToV8::to_v8(node, scope),
+            Self::TsIndexedAccessType(node) => ToV8::to_v8(node, scope),
+            Self::TsInferType(node) => ToV8::to_v8(node, scope),
+            Self::TsIntersectionType(node) => ToV8::to_v8(node, scope),
+            Self::TsMappedType(node) => ToV8::to_v8(node, scope),
+            Self::TsNeverType(node) => ToV8::to_v8(node, scope),
+            Self::TsNonPrimitiveType(node) => ToV8::to_v8(node, scope),
+            Self::TsNullLiteralType(node) => ToV8::to_v8(node, scope),
+            Self::TsNumberLiteralType(node) => ToV8::to_v8(node, scope),
+            Self::TsNumberType(node) => ToV8::to_v8(node, scope),
+            Self::TsObjectType(node) => ToV8::to_v8(node, scope),
+            Self::TsParenthesizedType(node) => ToV8::to_v8(node, scope),
+            Self::TsReferenceType(node) => ToV8::to_v8(node, scope),
+            Self::TsStringLiteralType(node) => ToV8::to_v8(node, scope),
+            Self::TsStringType(node) => ToV8::to_v8(node, scope),
+            Self::TsSymbolType(node) => ToV8::to_v8(node, scope),
+            Self::TsTemplateLiteralType(node) => ToV8::to_v8(node, scope),
+            Self::TsThisType(node) => ToV8::to_v8(node, scope),
+            Self::TsTupleType(node) => ToV8::to_v8(node, scope),
+            Self::TsTypeOperatorType(node) => ToV8::to_v8(node, scope),
+            Self::TsTypeofType(node) => ToV8::to_v8(node, scope),
+            Self::TsUndefinedType(node) => ToV8::to_v8(node, scope),
+            Self::TsUnionType(node) => ToV8::to_v8(node, scope),
+            Self::TsUnknownType(node) => ToV8::to_v8(node, scope),
+            Self::TsVoidType(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsTypeMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsBogusMember(node) => ToV8::to_v8(node, scope),
+            Self::TsCallSignatureTypeMember(node) => ToV8::to_v8(node, scope),
+            Self::TsConstructSignatureTypeMember(node) => ToV8::to_v8(node, scope),
+            Self::TsGetterSignatureTypeMember(node) => ToV8::to_v8(node, scope),
+            Self::TsIndexSignatureTypeMember(node) => ToV8::to_v8(node, scope),
+            Self::TsMethodSignatureTypeMember(node) => ToV8::to_v8(node, scope),
+            Self::TsPropertySignatureTypeMember(node) => ToV8::to_v8(node, scope),
+            Self::TsSetterSignatureTypeMember(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsTypeParameterModifier {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::TsConstModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsInModifier(node) => ToV8::to_v8(node, scope),
+            Self::TsOutModifier(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsTypePredicateParameterName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsReferenceIdentifier(node) => ToV8::to_v8(node, scope),
+            Self::TsThisType(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_js_syntax::AnyTsVariableAnnotation {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::TsDefiniteVariableAnnotation(node) => ToV8::to_v8(node, scope),
+            Self::TsTypeAnnotation(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsBogus);
+crate::convert::impl_convert_native!(rome_js_syntax::JsBogusAssignment);
+crate::convert::impl_convert_native!(rome_js_syntax::JsBogusBinding);
+crate::convert::impl_convert_native!(rome_js_syntax::JsBogusExpression);
+crate::convert::impl_convert_native!(rome_js_syntax::JsBogusImportAssertionEntry);
+crate::convert::impl_convert_native!(rome_js_syntax::JsBogusMember);
+crate::convert::impl_convert_native!(rome_js_syntax::JsBogusNamedImportSpecifier);
+crate::convert::impl_convert_native!(rome_js_syntax::JsBogusParameter);
+crate::convert::impl_convert_native!(rome_js_syntax::JsBogusStatement);
+crate::convert::impl_convert_native!(rome_js_syntax::TsBogusType);
+crate::convert::impl_convert_native!(rome_js_syntax::JsArrayAssignmentPatternElementList);
+#[allow(non_snake_case)]
+fn JsArrayAssignmentPatternElementList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsArrayAssignmentPatternElementList>::from_v8(scope, this)
+            .unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsArrayBindingPatternElementList);
+#[allow(non_snake_case)]
+fn JsArrayBindingPatternElementList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsArrayBindingPatternElementList>::from_v8(scope, this)
+            .unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsArrayElementList);
+#[allow(non_snake_case)]
+fn JsArrayElementList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsArrayElementList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsCallArgumentList);
+#[allow(non_snake_case)]
+fn JsCallArgumentList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsCallArgumentList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsClassMemberList);
+#[allow(non_snake_case)]
+fn JsClassMemberList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsClassMemberList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsConstructorModifierList);
+#[allow(non_snake_case)]
+fn JsConstructorModifierList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsConstructorModifierList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsConstructorParameterList);
+#[allow(non_snake_case)]
+fn JsConstructorParameterList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsConstructorParameterList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsDecoratorList);
+#[allow(non_snake_case)]
+fn JsDecoratorList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsDecoratorList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsDirectiveList);
+#[allow(non_snake_case)]
+fn JsDirectiveList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsDirectiveList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsExportNamedFromSpecifierList);
+#[allow(non_snake_case)]
+fn JsExportNamedFromSpecifierList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsExportNamedFromSpecifierList>::from_v8(scope, this)
+            .unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsExportNamedSpecifierList);
+#[allow(non_snake_case)]
+fn JsExportNamedSpecifierList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsExportNamedSpecifierList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsImportAssertionEntryList);
+#[allow(non_snake_case)]
+fn JsImportAssertionEntryList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsImportAssertionEntryList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsMethodModifierList);
+#[allow(non_snake_case)]
+fn JsMethodModifierList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsMethodModifierList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsModuleItemList);
+#[allow(non_snake_case)]
+fn JsModuleItemList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsModuleItemList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsNamedImportSpecifierList);
+#[allow(non_snake_case)]
+fn JsNamedImportSpecifierList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsNamedImportSpecifierList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsObjectAssignmentPatternPropertyList);
+#[allow(non_snake_case)]
+fn JsObjectAssignmentPatternPropertyList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsObjectAssignmentPatternPropertyList>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsObjectBindingPatternPropertyList);
+#[allow(non_snake_case)]
+fn JsObjectBindingPatternPropertyList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsObjectBindingPatternPropertyList>::from_v8(scope, this)
+            .unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsObjectMemberList);
+#[allow(non_snake_case)]
+fn JsObjectMemberList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsObjectMemberList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsParameterList);
+#[allow(non_snake_case)]
+fn JsParameterList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsParameterList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsPropertyModifierList);
+#[allow(non_snake_case)]
+fn JsPropertyModifierList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsPropertyModifierList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsStatementList);
+#[allow(non_snake_case)]
+fn JsStatementList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsStatementList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsSwitchCaseList);
+#[allow(non_snake_case)]
+fn JsSwitchCaseList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsSwitchCaseList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsTemplateElementList);
+#[allow(non_snake_case)]
+fn JsTemplateElementList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsTemplateElementList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsVariableDeclaratorList);
+#[allow(non_snake_case)]
+fn JsVariableDeclaratorList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::JsVariableDeclaratorList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsxAttributeList);
+#[allow(non_snake_case)]
+fn JsxAttributeList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsxAttributeList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::JsxChildList);
+#[allow(non_snake_case)]
+fn JsxChildList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::JsxChildList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsEnumMemberList);
+#[allow(non_snake_case)]
+fn TsEnumMemberList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::TsEnumMemberList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsIndexSignatureModifierList);
+#[allow(non_snake_case)]
+fn TsIndexSignatureModifierList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::TsIndexSignatureModifierList>::from_v8(scope, this)
+        .unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsIntersectionTypeElementList);
+#[allow(non_snake_case)]
+fn TsIntersectionTypeElementList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::TsIntersectionTypeElementList>::from_v8(scope, this)
+            .unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsMethodSignatureModifierList);
+#[allow(non_snake_case)]
+fn TsMethodSignatureModifierList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::TsMethodSignatureModifierList>::from_v8(scope, this)
+            .unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsPropertyParameterModifierList);
+#[allow(non_snake_case)]
+fn TsPropertyParameterModifierList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::TsPropertyParameterModifierList>::from_v8(scope, this)
+            .unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsPropertySignatureModifierList);
+#[allow(non_snake_case)]
+fn TsPropertySignatureModifierList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::TsPropertySignatureModifierList>::from_v8(scope, this)
+            .unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsTemplateElementList);
+#[allow(non_snake_case)]
+fn TsTemplateElementList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::TsTemplateElementList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsTupleTypeElementList);
+#[allow(non_snake_case)]
+fn TsTupleTypeElementList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::TsTupleTypeElementList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsTypeArgumentList);
+#[allow(non_snake_case)]
+fn TsTypeArgumentList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::TsTypeArgumentList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsTypeList);
+#[allow(non_snake_case)]
+fn TsTypeList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::TsTypeList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsTypeMemberList);
+#[allow(non_snake_case)]
+fn TsTypeMemberList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::TsTypeMemberList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsTypeParameterList);
+#[allow(non_snake_case)]
+fn TsTypeParameterList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::TsTypeParameterList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsTypeParameterModifierList);
+#[allow(non_snake_case)]
+fn TsTypeParameterModifierList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_js_syntax::TsTypeParameterModifierList>::from_v8(scope, this)
+        .unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_js_syntax::TsUnionTypeVariantList);
+#[allow(non_snake_case)]
+fn TsUnionTypeVariantList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_js_syntax::TsUnionTypeVariantList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsArrayAssignmentPatternElement >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsArrayBindingPatternElement >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsArrayElement >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsCallArgument >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsClassMember >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsConstructorParameter >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsExportNamedSpecifier >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsImportAssertionEntry >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsMethodModifier >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsModuleItem >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsNamedImportSpecifier >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsObjectAssignmentPatternMember >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsObjectBindingPatternMember >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsObjectMember >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsParameter >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsPropertyModifier >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsStatement >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsSwitchClause >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsTemplateElement >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsxAttribute >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyJsxChild >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyTsIndexSignatureModifier >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyTsMethodSignatureModifier >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyTsPropertyParameterModifier >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyTsPropertySignatureModifier >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyTsTemplateElement >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyTsTupleTypeElement >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyTsType >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyTsTypeMember >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: AnyTsTypeParameterModifier >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: JsDecorator >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: JsDirective >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: JsExportNamedFromSpecifier >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: JsVariableDeclarator >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstNodeListIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: TsAccessibilityModifier >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: TsEnumMember >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: TsNameWithTypeArguments >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_js_syntax :: JsLanguage , rome_js_syntax :: TsTypeParameter >);
diff --git a/crates/rome_v8/src/bindings/json.rs b/crates/rome_v8/src/bindings/json.rs
new file mode 100644
index 00000000000..aed88d48b3c
--- /dev/null
+++ b/crates/rome_v8/src/bindings/json.rs
@@ -0,0 +1,707 @@
+//! Generated file, do not edit by hand, see `xtask/codegen`
+
+use super::TemplateRegistry;
+use crate::convert::{FromV8, ToV8};
+use rome_rowan::{AstNode as _, AstNodeList as _, AstSeparatedList as _};
+pub(super) fn register_interfaces(
+    scope: &mut v8::HandleScope<'_, ()>,
+    global: v8::Local<'_, v8::ObjectTemplate>,
+    registry: &mut TemplateRegistry,
+) {
+    registry
+        .build_enum::<rome_json_syntax::JsonSyntaxKind>(scope, global, "JsonSyntaxKind")
+        .variant("EOF", rome_json_syntax::JsonSyntaxKind::EOF)
+        .variant("COLON", rome_json_syntax::JsonSyntaxKind::COLON)
+        .variant("COMMA", rome_json_syntax::JsonSyntaxKind::COMMA)
+        .variant("L_PAREN", rome_json_syntax::JsonSyntaxKind::L_PAREN)
+        .variant("R_PAREN", rome_json_syntax::JsonSyntaxKind::R_PAREN)
+        .variant("L_CURLY", rome_json_syntax::JsonSyntaxKind::L_CURLY)
+        .variant("R_CURLY", rome_json_syntax::JsonSyntaxKind::R_CURLY)
+        .variant("L_BRACK", rome_json_syntax::JsonSyntaxKind::L_BRACK)
+        .variant("R_BRACK", rome_json_syntax::JsonSyntaxKind::R_BRACK)
+        .variant("NULL_KW", rome_json_syntax::JsonSyntaxKind::NULL_KW)
+        .variant("TRUE_KW", rome_json_syntax::JsonSyntaxKind::TRUE_KW)
+        .variant("FALSE_KW", rome_json_syntax::JsonSyntaxKind::FALSE_KW)
+        .variant(
+            "JSON_STRING_LITERAL",
+            rome_json_syntax::JsonSyntaxKind::JSON_STRING_LITERAL,
+        )
+        .variant(
+            "JSON_NUMBER_LITERAL",
+            rome_json_syntax::JsonSyntaxKind::JSON_NUMBER_LITERAL,
+        )
+        .variant("ERROR_TOKEN", rome_json_syntax::JsonSyntaxKind::ERROR_TOKEN)
+        .variant("NEWLINE", rome_json_syntax::JsonSyntaxKind::NEWLINE)
+        .variant("WHITESPACE", rome_json_syntax::JsonSyntaxKind::WHITESPACE)
+        .variant("IDENT", rome_json_syntax::JsonSyntaxKind::IDENT)
+        .variant("COMMENT", rome_json_syntax::JsonSyntaxKind::COMMENT)
+        .variant(
+            "MULTILINE_COMMENT",
+            rome_json_syntax::JsonSyntaxKind::MULTILINE_COMMENT,
+        )
+        .variant("JSON_ROOT", rome_json_syntax::JsonSyntaxKind::JSON_ROOT)
+        .variant(
+            "JSON_NUMBER_VALUE",
+            rome_json_syntax::JsonSyntaxKind::JSON_NUMBER_VALUE,
+        )
+        .variant(
+            "JSON_STRING_VALUE",
+            rome_json_syntax::JsonSyntaxKind::JSON_STRING_VALUE,
+        )
+        .variant(
+            "JSON_BOOLEAN_VALUE",
+            rome_json_syntax::JsonSyntaxKind::JSON_BOOLEAN_VALUE,
+        )
+        .variant(
+            "JSON_NULL_VALUE",
+            rome_json_syntax::JsonSyntaxKind::JSON_NULL_VALUE,
+        )
+        .variant(
+            "JSON_ARRAY_VALUE",
+            rome_json_syntax::JsonSyntaxKind::JSON_ARRAY_VALUE,
+        )
+        .variant(
+            "JSON_OBJECT_VALUE",
+            rome_json_syntax::JsonSyntaxKind::JSON_OBJECT_VALUE,
+        )
+        .variant(
+            "JSON_MEMBER_LIST",
+            rome_json_syntax::JsonSyntaxKind::JSON_MEMBER_LIST,
+        )
+        .variant("JSON_MEMBER", rome_json_syntax::JsonSyntaxKind::JSON_MEMBER)
+        .variant(
+            "JSON_MEMBER_NAME",
+            rome_json_syntax::JsonSyntaxKind::JSON_MEMBER_NAME,
+        )
+        .variant(
+            "JSON_ARRAY_ELEMENT_LIST",
+            rome_json_syntax::JsonSyntaxKind::JSON_ARRAY_ELEMENT_LIST,
+        )
+        .variant("JSON_BOGUS", rome_json_syntax::JsonSyntaxKind::JSON_BOGUS)
+        .variant(
+            "JSON_BOGUS_VALUE",
+            rome_json_syntax::JsonSyntaxKind::JSON_BOGUS_VALUE,
+        )
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonArrayValue>(scope, global, "JsonArrayValue")
+        .extends::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>(scope)
+        .method(scope, "l_brack_token", JsonArrayValue_l_brack_token)
+        .method(scope, "elements", JsonArrayValue_elements)
+        .method(scope, "r_brack_token", JsonArrayValue_r_brack_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonBooleanValue>(scope, global, "JsonBooleanValue")
+        .extends::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>(scope)
+        .method(scope, "value_token", JsonBooleanValue_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonMember>(scope, global, "JsonMember")
+        .extends::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>(scope)
+        .method(scope, "name", JsonMember_name)
+        .method(scope, "colon_token", JsonMember_colon_token)
+        .method(scope, "value", JsonMember_value)
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonMemberName>(scope, global, "JsonMemberName")
+        .extends::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>(scope)
+        .method(scope, "value_token", JsonMemberName_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonNullValue>(scope, global, "JsonNullValue")
+        .extends::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>(scope)
+        .method(scope, "value_token", JsonNullValue_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonNumberValue>(scope, global, "JsonNumberValue")
+        .extends::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>(scope)
+        .method(scope, "value_token", JsonNumberValue_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonObjectValue>(scope, global, "JsonObjectValue")
+        .extends::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>(scope)
+        .method(scope, "l_curly_token", JsonObjectValue_l_curly_token)
+        .method(scope, "json_member_list", JsonObjectValue_json_member_list)
+        .method(scope, "r_curly_token", JsonObjectValue_r_curly_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonRoot>(scope, global, "JsonRoot")
+        .extends::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>(scope)
+        .method(scope, "value", JsonRoot_value)
+        .method(scope, "eof_token", JsonRoot_eof_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonStringValue>(scope, global, "JsonStringValue")
+        .extends::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>(scope)
+        .method(scope, "value_token", JsonStringValue_value_token)
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonBogus>(scope, global, "JsonBogus")
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonBogusValue>(scope, global, "JsonBogusValue")
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonArrayElementList>(
+            scope,
+            global,
+            "JsonArrayElementList",
+        )
+        .method(scope, "iter", JsonArrayElementList_iter)
+        .finish(scope);
+    registry
+        .build_class::<rome_json_syntax::JsonMemberList>(scope, global, "JsonMemberList")
+        .method(scope, "iter", JsonMemberList_iter)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_json_syntax::JsonLanguage,
+            rome_json_syntax::AnyJsonValue,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+    registry
+        .build_interface::<rome_rowan::AstSeparatedListNodesIterator<
+            rome_json_syntax::JsonLanguage,
+            rome_json_syntax::JsonMember,
+        >>(scope)
+        .iterable(scope, AstSeparatedListNodesIterator_next)
+        .finish(scope);
+}
+#[allow(non_snake_case)]
+fn AstSeparatedListNodesIterator_next<'s, T: ToV8<'s>>(
+    item: rome_rowan::SyntaxResult<T>,
+    scope: &mut v8::HandleScope<'s>,
+) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+    ToV8::to_v8(item?, scope)
+}
+impl<'s> ToV8<'s> for rome_json_syntax::JsonArrayValue {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_json_syntax::JsonArrayValue,
+            rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsonArrayValue_l_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonArrayValue::cast_ref(&*this).unwrap();
+    let result = this.l_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsonArrayValue_elements<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonArrayValue::cast_ref(&*this).unwrap();
+    let result = this.elements();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsonArrayValue_r_brack_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonArrayValue::cast_ref(&*this).unwrap();
+    let result = this.r_brack_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_json_syntax::JsonBooleanValue {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_json_syntax::JsonBooleanValue,
+            rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsonBooleanValue_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonBooleanValue::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_json_syntax::JsonMember {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_json_syntax::JsonMember,
+            rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsonMember_name<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonMember::cast_ref(&*this).unwrap();
+    let result = this.name();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsonMember_colon_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonMember::cast_ref(&*this).unwrap();
+    let result = this.colon_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsonMember_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonMember::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_json_syntax::JsonMemberName {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_json_syntax::JsonMemberName,
+            rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsonMemberName_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonMemberName::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_json_syntax::JsonNullValue {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_json_syntax::JsonNullValue,
+            rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsonNullValue_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonNullValue::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_json_syntax::JsonNumberValue {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_json_syntax::JsonNumberValue,
+            rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsonNumberValue_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonNumberValue::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_json_syntax::JsonObjectValue {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_json_syntax::JsonObjectValue,
+            rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsonObjectValue_l_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonObjectValue::cast_ref(&*this).unwrap();
+    let result = this.l_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsonObjectValue_json_member_list<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonObjectValue::cast_ref(&*this).unwrap();
+    let result = this.json_member_list();
+    let result = ToV8::to_v8(result, scope).unwrap();
+    res.set(result);
+}
+#[allow(non_snake_case)]
+fn JsonObjectValue_r_curly_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonObjectValue::cast_ref(&*this).unwrap();
+    let result = this.r_curly_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_json_syntax::JsonRoot {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_json_syntax::JsonRoot,
+            rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsonRoot_value<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonRoot::cast_ref(&*this).unwrap();
+    let result = this.value();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+#[allow(non_snake_case)]
+fn JsonRoot_eof_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonRoot::cast_ref(&*this).unwrap();
+    let result = this.eof_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_json_syntax::JsonStringValue {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        let node = self.into_syntax();
+        crate::registry::instantiate_as::<
+            rome_json_syntax::JsonStringValue,
+            rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>,
+        >(scope, node)
+        .map(Into::into)
+    }
+}
+#[allow(non_snake_case)]
+fn JsonStringValue_value_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_rowan::SyntaxNode<rome_json_syntax::JsonLanguage>>::from_v8(
+        scope, this,
+    )
+    .unwrap();
+    let this = rome_json_syntax::JsonStringValue::cast_ref(&*this).unwrap();
+    let result = this.value_token();
+    match result {
+        Ok(result) => {
+            let result = ToV8::to_v8(result, scope).unwrap();
+            res.set(result);
+        }
+        Err(err) => {
+            let message = err.to_string();
+            let message = v8::String::new(scope, &message).unwrap();
+            let exception = v8::Exception::error(scope, message);
+            scope.throw_exception(exception);
+        }
+    }
+}
+impl<'s> ToV8<'s> for rome_json_syntax::AnyJsonValue {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+        match self {
+            Self::JsonArrayValue(node) => ToV8::to_v8(node, scope),
+            Self::JsonBogusValue(node) => ToV8::to_v8(node, scope),
+            Self::JsonBooleanValue(node) => ToV8::to_v8(node, scope),
+            Self::JsonNullValue(node) => ToV8::to_v8(node, scope),
+            Self::JsonNumberValue(node) => ToV8::to_v8(node, scope),
+            Self::JsonObjectValue(node) => ToV8::to_v8(node, scope),
+            Self::JsonStringValue(node) => ToV8::to_v8(node, scope),
+        }
+    }
+}
+crate::convert::impl_convert_native!(rome_json_syntax::JsonBogus);
+crate::convert::impl_convert_native!(rome_json_syntax::JsonBogusValue);
+crate::convert::impl_convert_native!(rome_json_syntax::JsonArrayElementList);
+#[allow(non_snake_case)]
+fn JsonArrayElementList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this =
+        std::cell::Ref::<rome_json_syntax::JsonArrayElementList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate::convert::impl_convert_native!(rome_json_syntax::JsonMemberList);
+#[allow(non_snake_case)]
+fn JsonMemberList_iter<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = std::cell::Ref::<rome_json_syntax::JsonMemberList>::from_v8(scope, this).unwrap();
+    let iter = this.iter();
+    let iter = ToV8::to_v8(iter, scope).unwrap();
+    res.set(iter);
+}
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_json_syntax :: JsonLanguage , rome_json_syntax :: AnyJsonValue >);
+crate :: convert :: impl_convert_native ! (rome_rowan :: AstSeparatedListNodesIterator < rome_json_syntax :: JsonLanguage , rome_json_syntax :: JsonMember >);
diff --git a/crates/rome_v8/src/bindings/rowan.idl b/crates/rome_v8/src/bindings/rowan.idl
new file mode 100644
index 00000000000..71863694c64
--- /dev/null
+++ b/crates/rome_v8/src/bindings/rowan.idl
@@ -0,0 +1,167 @@
+[RustType="rome_rowan::TextRange"]
+typedef sequence<unsigned long> TextRange;
+
+[RustType="rome_rowan::SyntaxNodeText"]
+interface SyntaxNodeText {
+    unsigned short len();
+    boolean is_empty();
+    DOMString to_string();
+};
+
+[RustType="rome_js_syntax::JsSyntaxKind"]
+typedef any JsSyntaxKind;
+
+interface JsSyntaxTriviaPiece {
+    DOMString text();
+    unsigned long text_len();
+    TextRange text_range();
+    boolean is_newline();
+    boolean is_whitespace();
+    boolean is_comments();
+    boolean is_skipped();
+    JsSyntaxToken token();
+};
+
+[RustType="rome_js_syntax::JsSyntaxTrivia"]
+interface JsSyntaxTrivia {
+    // pieces();
+    JsSyntaxTriviaPiece? last();
+    JsSyntaxTriviaPiece? first();
+    DOMString text();
+    TextRange text_range();
+    boolean is_empty();
+    boolean has_skipped();
+};
+
+[RustType="rome_js_syntax::JsSyntaxToken",Exposed="*"]
+interface JsSyntaxToken {
+    JsSyntaxKind kind();
+    TextRange text_range();
+    TextRange text_trimmed_range();
+    DOMString text();
+    DOMString text_trimmed();
+    JsSyntaxNode? parent();
+    // ancestors();
+    JsSyntaxElement? next_sibling_or_token();
+    JsSyntaxElement? prev_sibling_or_token();
+    // siblings_with_tokens();
+    JsSyntaxToken? next_token();
+    JsSyntaxToken? prev_token();
+    [ClonedThis] JsSyntaxToken detach();
+    // JsSyntaxToken with_leading_trivia();
+    // JsSyntaxToken with_trailing_trivia();
+    JsSyntaxTrivia leading_trivia();
+    JsSyntaxTrivia trailing_trivia();
+    boolean has_trailing_comments();
+    boolean has_leading_comments();
+    boolean has_leading_non_whitespace_trivia();
+};
+
+[RustType="rome_js_syntax::JsSyntaxElement"]
+typedef (JsSyntaxNode or JsSyntaxToken) JsSyntaxElement;
+
+[RustType="rome_js_syntax::JsSyntaxList",Exposed="*"]
+interface JsSyntaxList {
+    // iter();
+    unsigned long len();
+    boolean is_empty();
+    JsSyntaxNode? first();
+    JsSyntaxNode? last();
+    [ClonedResult] JsSyntaxNode node();
+};
+
+[RustType="rome_js_syntax::JsSyntaxNode",Exposed="*"]
+interface JsSyntaxNode {
+    JsSyntaxKind kind();
+    SyntaxNodeText text();
+    SyntaxNodeText text_trimmed();
+    TextRange text_range();
+    TextRange text_trimmed_range();
+    JsSyntaxTrivia? first_leading_trivia();
+    JsSyntaxTrivia? last_trailing_trivia();
+    JsSyntaxNode? parent();
+    JsSyntaxNode? grand_parent();
+    unsigned long index();
+    // ancestors();
+    // children();
+    // slots();
+    // children_with_tokens();
+    // tokens();
+    JsSyntaxNode? first_child();
+    JsSyntaxNode? last_child();
+    JsSyntaxElement? first_child_or_token();
+    JsSyntaxElement? last_child_or_token();
+    JsSyntaxNode? next_sibling();
+    JsSyntaxNode? prev_sibling();
+    JsSyntaxElement? next_sibling_or_token();
+    JsSyntaxElement? prev_sibling_or_token();
+    JsSyntaxToken? first_token();
+    JsSyntaxToken? last_token();
+    // siblings();
+    // siblings_with_tokens();
+    JsDescendants descendants();
+    JsDescendantsTokens descendants_tokens(optional Direction direction = "rome_rowan::Direction::Next");
+    JsDescendantsWithTokens descendants_with_tokens(optional Direction direction = "rome_rowan::Direction::Next");
+    JsPreorder preorder();
+    // JsPreorderWithTokens preorder_with_tokens();
+    // token_at_offset();
+    JsSyntaxElement covering_element(TextRange range);
+    JsSyntaxElement? child_or_token_at_range(TextRange range);
+    JsSyntaxNode clone_subtree();
+    [ClonedThis] JsSyntaxNode detach();
+    [CustomBinding] JsSyntaxNode splice_slots(sequence<unsigned long> range, sequence<JsSyntaxElement> replace_with);
+    [ClonedThis] JsSyntaxNode? replace_child(JsSyntaxElement prev_element, JsSyntaxElement next_element);
+    [ClonedThis] JsSyntaxList into_list();
+    boolean has_comments_descendants();
+    boolean has_comments_direct();
+    boolean first_or_last_token_have_comments();
+    boolean has_trailing_comments();
+    boolean last_token_has_comments();
+    boolean first_token_has_comments();
+    boolean has_leading_comments();
+};
+
+[RustType="rome_rowan::Direction"]
+enum Direction {
+    "Next",
+    "Prev"
+};
+
+interface JsDescendants {
+    iterable<JsSyntaxNode>;
+};
+
+interface JsDescendantsTokens {
+    iterable<JsSyntaxToken>;
+};
+
+interface JsDescendantsWithTokens {
+    iterable<JsSyntaxElement>;
+};
+
+interface JsPreorder {
+    iterable<JsWalkEvent>;
+};
+
+enum JsWalkEventKind {
+    "Enter",
+    "Leave"
+};
+
+interface JsWalkEvent {
+    attribute JsWalkEventKind kind;
+    attribute JsSyntaxNode elem;
+};
+
+[RustType="rome_js_factory::make",Exposed="*"]
+namespace make {
+    JsSyntaxToken ident([ByRef] DOMString text);
+};
+
+[Exposed="*"]
+interface JsBatchMutation {
+    constructor([Cloned] JsSyntaxNode root);
+    [MutableThis] undefined replace_element(JsSyntaxElement prev_element, JsSyntaxElement next_element);
+    [MutableThis] undefined replace_element_discard_trivia(JsSyntaxElement prev_element, JsSyntaxElement next_element);
+    [MutableThis] undefined remove_element(JsSyntaxElement prev_element);
+};
diff --git a/crates/rome_v8/src/bindings/rowan.idl.rs b/crates/rome_v8/src/bindings/rowan.idl.rs
new file mode 100644
index 00000000000..b90d324790a
--- /dev/null
+++ b/crates/rome_v8/src/bindings/rowan.idl.rs
@@ -0,0 +1,1404 @@
+use crate::convert::{FromV8, ToV8};
+use super::TemplateRegistry;
+pub(super) fn register_interfaces(
+    scope: &mut v8::HandleScope<'_, ()>,
+    global: v8::Local<'_, v8::ObjectTemplate>,
+    registry: &mut TemplateRegistry,
+) {
+    registry
+        .build_class_with_constructor::<
+            JsBatchMutation,
+        >(scope, global, "JsBatchMutation", JsBatchMutation_constructor)
+        .method(scope, "replace_element", JsBatchMutation_replace_element)
+        .method(
+            scope,
+            "replace_element_discard_trivia",
+            JsBatchMutation_replace_element_discard_trivia,
+        )
+        .method(scope, "remove_element", JsBatchMutation_remove_element)
+        .finish(scope);
+    registry
+        .build_interface::<JsDescendants>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<JsDescendantsTokens>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<JsDescendantsWithTokens>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_interface::<JsPreorder>(scope)
+        .iterable(scope, ToV8::to_v8)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsSyntaxList>(scope, global, "JsSyntaxList")
+        .method(scope, "len", JsSyntaxList_len)
+        .method(scope, "is_empty", JsSyntaxList_is_empty)
+        .method(scope, "first", JsSyntaxList_first)
+        .method(scope, "last", JsSyntaxList_last)
+        .method(scope, "node", JsSyntaxList_node)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsSyntaxNode>(scope, global, "JsSyntaxNode")
+        .method(scope, "kind", JsSyntaxNode_kind)
+        .method(scope, "text", JsSyntaxNode_text)
+        .method(scope, "text_trimmed", JsSyntaxNode_text_trimmed)
+        .method(scope, "text_range", JsSyntaxNode_text_range)
+        .method(scope, "text_trimmed_range", JsSyntaxNode_text_trimmed_range)
+        .method(scope, "first_leading_trivia", JsSyntaxNode_first_leading_trivia)
+        .method(scope, "last_trailing_trivia", JsSyntaxNode_last_trailing_trivia)
+        .method(scope, "parent", JsSyntaxNode_parent)
+        .method(scope, "grand_parent", JsSyntaxNode_grand_parent)
+        .method(scope, "index", JsSyntaxNode_index)
+        .method(scope, "first_child", JsSyntaxNode_first_child)
+        .method(scope, "last_child", JsSyntaxNode_last_child)
+        .method(scope, "first_child_or_token", JsSyntaxNode_first_child_or_token)
+        .method(scope, "last_child_or_token", JsSyntaxNode_last_child_or_token)
+        .method(scope, "next_sibling", JsSyntaxNode_next_sibling)
+        .method(scope, "prev_sibling", JsSyntaxNode_prev_sibling)
+        .method(scope, "next_sibling_or_token", JsSyntaxNode_next_sibling_or_token)
+        .method(scope, "prev_sibling_or_token", JsSyntaxNode_prev_sibling_or_token)
+        .method(scope, "first_token", JsSyntaxNode_first_token)
+        .method(scope, "last_token", JsSyntaxNode_last_token)
+        .method(scope, "descendants", JsSyntaxNode_descendants)
+        .method(scope, "descendants_tokens", JsSyntaxNode_descendants_tokens)
+        .method(scope, "descendants_with_tokens", JsSyntaxNode_descendants_with_tokens)
+        .method(scope, "preorder", JsSyntaxNode_preorder)
+        .method(scope, "covering_element", JsSyntaxNode_covering_element)
+        .method(scope, "child_or_token_at_range", JsSyntaxNode_child_or_token_at_range)
+        .method(scope, "clone_subtree", JsSyntaxNode_clone_subtree)
+        .method(scope, "detach", JsSyntaxNode_detach)
+        .method(scope, "splice_slots", JsSyntaxNode_splice_slots)
+        .method(scope, "replace_child", JsSyntaxNode_replace_child)
+        .method(scope, "into_list", JsSyntaxNode_into_list)
+        .method(scope, "has_comments_descendants", JsSyntaxNode_has_comments_descendants)
+        .method(scope, "has_comments_direct", JsSyntaxNode_has_comments_direct)
+        .method(
+            scope,
+            "first_or_last_token_have_comments",
+            JsSyntaxNode_first_or_last_token_have_comments,
+        )
+        .method(scope, "has_trailing_comments", JsSyntaxNode_has_trailing_comments)
+        .method(scope, "last_token_has_comments", JsSyntaxNode_last_token_has_comments)
+        .method(scope, "first_token_has_comments", JsSyntaxNode_first_token_has_comments)
+        .method(scope, "has_leading_comments", JsSyntaxNode_has_leading_comments)
+        .finish(scope);
+    registry
+        .build_class::<rome_js_syntax::JsSyntaxToken>(scope, global, "JsSyntaxToken")
+        .method(scope, "kind", JsSyntaxToken_kind)
+        .method(scope, "text_range", JsSyntaxToken_text_range)
+        .method(scope, "text_trimmed_range", JsSyntaxToken_text_trimmed_range)
+        .method(scope, "text", JsSyntaxToken_text)
+        .method(scope, "text_trimmed", JsSyntaxToken_text_trimmed)
+        .method(scope, "parent", JsSyntaxToken_parent)
+        .method(scope, "next_sibling_or_token", JsSyntaxToken_next_sibling_or_token)
+        .method(scope, "prev_sibling_or_token", JsSyntaxToken_prev_sibling_or_token)
+        .method(scope, "next_token", JsSyntaxToken_next_token)
+        .method(scope, "prev_token", JsSyntaxToken_prev_token)
+        .method(scope, "detach", JsSyntaxToken_detach)
+        .method(scope, "leading_trivia", JsSyntaxToken_leading_trivia)
+        .method(scope, "trailing_trivia", JsSyntaxToken_trailing_trivia)
+        .method(scope, "has_trailing_comments", JsSyntaxToken_has_trailing_comments)
+        .method(scope, "has_leading_comments", JsSyntaxToken_has_leading_comments)
+        .method(
+            scope,
+            "has_leading_non_whitespace_trivia",
+            JsSyntaxToken_has_leading_non_whitespace_trivia,
+        )
+        .finish(scope);
+    registry
+        .build_interface::<rome_js_syntax::JsSyntaxTrivia>(scope)
+        .method(scope, "last", JsSyntaxTrivia_last)
+        .method(scope, "first", JsSyntaxTrivia_first)
+        .method(scope, "text", JsSyntaxTrivia_text)
+        .method(scope, "text_range", JsSyntaxTrivia_text_range)
+        .method(scope, "is_empty", JsSyntaxTrivia_is_empty)
+        .method(scope, "has_skipped", JsSyntaxTrivia_has_skipped)
+        .finish(scope);
+    registry
+        .build_interface::<JsSyntaxTriviaPiece>(scope)
+        .method(scope, "text", JsSyntaxTriviaPiece_text)
+        .method(scope, "text_len", JsSyntaxTriviaPiece_text_len)
+        .method(scope, "text_range", JsSyntaxTriviaPiece_text_range)
+        .method(scope, "is_newline", JsSyntaxTriviaPiece_is_newline)
+        .method(scope, "is_whitespace", JsSyntaxTriviaPiece_is_whitespace)
+        .method(scope, "is_comments", JsSyntaxTriviaPiece_is_comments)
+        .method(scope, "is_skipped", JsSyntaxTriviaPiece_is_skipped)
+        .method(scope, "token", JsSyntaxTriviaPiece_token)
+        .finish(scope);
+    registry.build_interface::<JsWalkEvent>(scope).finish(scope);
+    registry
+        .build_interface::<rome_rowan::SyntaxNodeText>(scope)
+        .method(scope, "len", SyntaxNodeText_len)
+        .method(scope, "is_empty", SyntaxNodeText_is_empty)
+        .method(scope, "to_string", SyntaxNodeText_to_string)
+        .finish(scope);
+    registry.build_namespace(scope, global, "make").method(scope, "ident", make_ident);
+}
+#[allow(non_snake_case)]
+fn JsBatchMutation_constructor<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    _res: v8::ReturnValue,
+) {
+    let root = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, args.get(0i32))
+        .expect("could not load native object from JS value")
+        .clone();
+    let res = JsBatchMutation::new(root);
+    crate::registry::store_native(scope, args.this(), res);
+}
+#[allow(non_snake_case)]
+fn JsBatchMutation_replace_element<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    _result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let mut this = <std::cell::RefMut<JsBatchMutation> as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let prev_element = <rome_js_syntax::JsSyntaxElement as FromV8>::from_v8(
+            scope,
+            args.get(0i32),
+        )
+        .expect("failed to deserialize argument from V8 value");
+    let next_element = <rome_js_syntax::JsSyntaxElement as FromV8>::from_v8(
+            scope,
+            args.get(1i32),
+        )
+        .expect("failed to deserialize argument from V8 value");
+    this.replace_element(prev_element, next_element);
+}
+#[allow(non_snake_case)]
+fn JsBatchMutation_replace_element_discard_trivia<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    _result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let mut this = <std::cell::RefMut<JsBatchMutation> as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let prev_element = <rome_js_syntax::JsSyntaxElement as FromV8>::from_v8(
+            scope,
+            args.get(0i32),
+        )
+        .expect("failed to deserialize argument from V8 value");
+    let next_element = <rome_js_syntax::JsSyntaxElement as FromV8>::from_v8(
+            scope,
+            args.get(1i32),
+        )
+        .expect("failed to deserialize argument from V8 value");
+    this.replace_element_discard_trivia(prev_element, next_element);
+}
+#[allow(non_snake_case)]
+fn JsBatchMutation_remove_element<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    _result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let mut this = <std::cell::RefMut<JsBatchMutation> as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let prev_element = <rome_js_syntax::JsSyntaxElement as FromV8>::from_v8(
+            scope,
+            args.get(0i32),
+        )
+        .expect("failed to deserialize argument from V8 value");
+    this.remove_element(prev_element);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxList_len<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxList,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.len();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxList_is_empty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxList,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.is_empty();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxList_first<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxList,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.first() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxList_last<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxList,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.last() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxList_node<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxList,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.node();
+    let res = res.clone();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_kind<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.kind();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_text<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_text_trimmed<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text_trimmed();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_text_range<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text_range();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_text_trimmed_range<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text_trimmed_range();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_first_leading_trivia<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.first_leading_trivia() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_last_trailing_trivia<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.last_trailing_trivia() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_parent<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.parent() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_grand_parent<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.grand_parent() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_index<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.index();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_first_child<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.first_child() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_last_child<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.last_child() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_first_child_or_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.first_child_or_token();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_last_child_or_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.last_child_or_token();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_next_sibling<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.next_sibling() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_prev_sibling<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.prev_sibling() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_next_sibling_or_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.next_sibling_or_token();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_prev_sibling_or_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.prev_sibling_or_token();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_first_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.first_token() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_last_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.last_token() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_descendants<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.descendants();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_descendants_tokens<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let direction = if let Some(direction)
+        = <Option<rome_rowan::Direction> as FromV8>::from_v8(scope, args.get(0i32))
+            .expect("failed to deserialize argument from V8 value")
+    {
+        direction
+    } else {
+        rome_rowan::Direction::Next
+    };
+    let res = this.descendants_tokens(direction);
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_descendants_with_tokens<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let direction = if let Some(direction)
+        = <Option<rome_rowan::Direction> as FromV8>::from_v8(scope, args.get(0i32))
+            .expect("failed to deserialize argument from V8 value")
+    {
+        direction
+    } else {
+        rome_rowan::Direction::Next
+    };
+    let res = this.descendants_with_tokens(direction);
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_preorder<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.preorder();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_covering_element<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let range = <rome_rowan::TextRange as FromV8>::from_v8(scope, args.get(0i32))
+        .expect("failed to deserialize argument from V8 value");
+    let res = this.covering_element(range);
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_child_or_token_at_range<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let range = <rome_rowan::TextRange as FromV8>::from_v8(scope, args.get(0i32))
+        .expect("failed to deserialize argument from V8 value");
+    let res = this.child_or_token_at_range(range);
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_clone_subtree<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.clone_subtree();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_detach<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let this = this.clone();
+    let res = this.detach();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_replace_child<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let this = this.clone();
+    let prev_element = <rome_js_syntax::JsSyntaxElement as FromV8>::from_v8(
+            scope,
+            args.get(0i32),
+        )
+        .expect("failed to deserialize argument from V8 value");
+    let next_element = <rome_js_syntax::JsSyntaxElement as FromV8>::from_v8(
+            scope,
+            args.get(1i32),
+        )
+        .expect("failed to deserialize argument from V8 value");
+    if let Some(res) = this.replace_child(prev_element, next_element) {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_into_list<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let this = this.clone();
+    let res = this.into_list();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_has_comments_descendants<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.has_comments_descendants();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_has_comments_direct<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.has_comments_direct();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_first_or_last_token_have_comments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.first_or_last_token_have_comments();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_has_trailing_comments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.has_trailing_comments();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_last_token_has_comments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.last_token_has_comments();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_first_token_has_comments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.first_token_has_comments();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxNode_has_leading_comments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxNode,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.has_leading_comments();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_kind<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.kind();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_text_range<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text_range();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_text_trimmed_range<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text_trimmed_range();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_text<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_text_trimmed<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text_trimmed();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_parent<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.parent() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_next_sibling_or_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.next_sibling_or_token();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_prev_sibling_or_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.prev_sibling_or_token();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_next_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.next_token() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_prev_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.prev_token() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_detach<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let this = this.clone();
+    let res = this.detach();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_leading_trivia<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.leading_trivia();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_trailing_trivia<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.trailing_trivia();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_has_trailing_comments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.has_trailing_comments();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_has_leading_comments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.has_leading_comments();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxToken_has_leading_non_whitespace_trivia<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxToken,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.has_leading_non_whitespace_trivia();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTrivia_last<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxTrivia,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.last() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTrivia_first<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxTrivia,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    if let Some(res) = this.first() {
+        let res = ToV8::to_v8(res, scope)
+            .expect("failed to serialize result to JS value");
+        result.set(res);
+    }
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTrivia_text<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxTrivia,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTrivia_text_range<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxTrivia,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text_range();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTrivia_is_empty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxTrivia,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.is_empty();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTrivia_has_skipped<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_js_syntax::JsSyntaxTrivia,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.has_skipped();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTriviaPiece_text<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<JsSyntaxTriviaPiece> as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTriviaPiece_text_len<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<JsSyntaxTriviaPiece> as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text_len();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTriviaPiece_text_range<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<JsSyntaxTriviaPiece> as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.text_range();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTriviaPiece_is_newline<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<JsSyntaxTriviaPiece> as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.is_newline();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTriviaPiece_is_whitespace<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<JsSyntaxTriviaPiece> as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.is_whitespace();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTriviaPiece_is_comments<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<JsSyntaxTriviaPiece> as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.is_comments();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTriviaPiece_is_skipped<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<JsSyntaxTriviaPiece> as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.is_skipped();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn JsSyntaxTriviaPiece_token<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<JsSyntaxTriviaPiece> as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.token();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn SyntaxNodeText_len<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_rowan::SyntaxNodeText,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.len();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn SyntaxNodeText_is_empty<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_rowan::SyntaxNodeText,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.is_empty();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn SyntaxNodeText_to_string<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = <std::cell::Ref<
+        rome_rowan::SyntaxNodeText,
+    > as FromV8>::from_v8(scope, this)
+        .unwrap();
+    let res = this.to_string();
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
+#[allow(non_snake_case)]
+fn make_ident<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let text = <String as FromV8>::from_v8(scope, args.get(0i32))
+        .expect("failed to deserialize argument from V8 value");
+    let res = rome_js_factory::make::ident(&text);
+    let res = ToV8::to_v8(res, scope).expect("failed to serialize result to JS value");
+    result.set(res);
+}
diff --git a/crates/rome_v8/src/bindings/rowan_idl.rs b/crates/rome_v8/src/bindings/rowan_idl.rs
new file mode 100644
index 00000000000..239e08d0db8
--- /dev/null
+++ b/crates/rome_v8/src/bindings/rowan_idl.rs
@@ -0,0 +1,46 @@
+use std::cell::Ref;
+
+use rome_js_syntax::{JsLanguage, JsSyntaxNode, WalkEvent};
+use rome_rowan::{
+    syntax::{Descendants, DescendantsTokens, DescendantsWithTokens, Preorder},
+    BatchMutation, SyntaxTriviaPiece,
+};
+
+type JsSyntaxTriviaPiece = SyntaxTriviaPiece<JsLanguage>;
+type JsPreorder = Preorder<JsLanguage>;
+type JsDescendants = Descendants<JsLanguage>;
+type JsDescendantsTokens = DescendantsTokens<JsLanguage>;
+type JsDescendantsWithTokens = DescendantsWithTokens<JsLanguage>;
+type JsWalkEvent = WalkEvent<JsSyntaxNode>;
+type JsBatchMutation = BatchMutation<JsLanguage>;
+
+include!("rowan.idl.rs");
+
+#[allow(non_snake_case)]
+fn JsSyntaxNode_splice_slots<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut result: v8::ReturnValue,
+) {
+    let this = args.this().into();
+    let this = Ref::<rome_js_syntax::JsSyntaxNode>::from_v8(scope, this).unwrap();
+    let this = this.clone();
+
+    let range = args.get(0i32);
+    let range: std::ops::Range<usize> =
+        serde_v8::from_v8(scope, range).expect("failed to deserialize value from V8");
+
+    let replace_with = args.get(1i32);
+    let replace_with =
+        v8::Local::<v8::Array>::try_from(replace_with).expect("invalid argument type");
+    let length = replace_with.length();
+    let replace_with = (0..length).map(|index| {
+        let item = replace_with.get_index(scope, index)?;
+        let item = rome_js_syntax::JsSyntaxElement::from_v8(scope, item).ok()?;
+        Some(item)
+    });
+
+    let res = this.splice_slots(range, replace_with);
+    let res = ToV8::to_v8(res, scope).unwrap();
+    result.set(res);
+}
diff --git a/crates/rome_v8/src/convert.rs b/crates/rome_v8/src/convert.rs
new file mode 100644
index 00000000000..ec2ee9b8b91
--- /dev/null
+++ b/crates/rome_v8/src/convert.rs
@@ -0,0 +1,189 @@
+use std::cell::Ref;
+
+use anyhow::{bail, Context, Result};
+use rome_js_syntax::{
+    JsLanguage, JsSyntaxElement, JsSyntaxKind, JsSyntaxList, JsSyntaxNode, JsSyntaxToken,
+    JsSyntaxTrivia, SyntaxNodeText, TextRange, TextSize, WalkEvent,
+};
+use rome_rowan::{
+    syntax::{Descendants, DescendantsTokens, DescendantsWithTokens, Preorder},
+    BatchMutation, Direction, RawSyntaxKind, SyntaxSlot, SyntaxTriviaPiece,
+};
+
+pub(crate) trait FromV8<'s>: Sized {
+    fn from_v8(scope: &mut v8::HandleScope<'s>, value: v8::Local<'s, v8::Value>) -> Result<Self>;
+}
+
+pub(crate) trait ToV8<'s> {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> Result<v8::Local<'s, v8::Value>>;
+}
+
+macro_rules! impl_convert_serde {
+    ($ty:ty) => {
+        impl<'s> FromV8<'s> for $ty {
+            fn from_v8(
+                scope: &mut v8::HandleScope<'s>,
+                value: v8::Local<'s, v8::Value>,
+            ) -> Result<Self> {
+                serde_v8::from_v8(scope, value)
+                    .context("could not deserialize object from JS value")
+            }
+        }
+
+        impl<'s> ToV8<'s> for $ty {
+            fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> Result<v8::Local<'s, v8::Value>> {
+                serde_v8::to_v8(scope, self).context("could not serialize object to JS value")
+            }
+        }
+    };
+}
+
+impl_convert_serde!(bool);
+impl_convert_serde!(i16);
+impl_convert_serde!(i32);
+impl_convert_serde!(i64);
+impl_convert_serde!(isize);
+impl_convert_serde!(u16);
+impl_convert_serde!(u32);
+impl_convert_serde!(u64);
+impl_convert_serde!(usize);
+impl_convert_serde!(f32);
+impl_convert_serde!(f64);
+impl_convert_serde!(String);
+
+impl<'s> FromV8<'s> for &'s str {
+    fn from_v8(scope: &mut v8::HandleScope<'s>, value: v8::Local<'s, v8::Value>) -> Result<Self> {
+        serde_v8::from_v8(scope, value).context("could not deserialize object from JS value")
+    }
+}
+
+impl<'s, 'str> ToV8<'s> for &'str str {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> Result<v8::Local<'s, v8::Value>> {
+        serde_v8::to_v8(scope, self).context("could not serialize object to JS value")
+    }
+}
+
+impl<'s, T: FromV8<'s>> FromV8<'s> for Option<T> {
+    fn from_v8(scope: &mut v8::HandleScope<'s>, value: v8::Local<'s, v8::Value>) -> Result<Self> {
+        if !value.is_null_or_undefined() {
+            T::from_v8(scope, value).map(Some)
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+impl<'s, T: ToV8<'s>> ToV8<'s> for Option<T> {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> Result<v8::Local<'s, v8::Value>> {
+        if let Some(value) = self {
+            value.to_v8(scope)
+        } else {
+            Ok(v8::undefined(scope).into())
+        }
+    }
+}
+
+impl_convert_serde!(TextRange);
+impl_convert_serde!(TextSize);
+impl_convert_serde!(RawSyntaxKind);
+impl_convert_serde!(Direction);
+
+macro_rules! impl_convert_native {
+    ($ty:ty) => {
+        impl<'s> FromV8<'s> for std::cell::Ref<'s, $ty> {
+            fn from_v8(
+                _scope: &mut v8::HandleScope<'s>,
+                value: v8::Local<'s, v8::Value>,
+            ) -> anyhow::Result<Self> {
+                crate::registry::borrow_native(value)
+            }
+        }
+
+        impl<'s> FromV8<'s> for std::cell::RefMut<'s, $ty> {
+            fn from_v8(
+                _scope: &mut v8::HandleScope<'s>,
+                value: v8::Local<'s, v8::Value>,
+            ) -> anyhow::Result<Self> {
+                crate::registry::borrow_mut_native(value)
+            }
+        }
+
+        impl<'s> ToV8<'s> for $ty {
+            fn to_v8(
+                self,
+                scope: &mut v8::HandleScope<'s>,
+            ) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+                crate::registry::instantiate(scope, self).map(Into::into)
+            }
+        }
+    };
+}
+
+pub(crate) use impl_convert_native;
+
+impl_convert_native!(SyntaxNodeText);
+impl_convert_native!(SyntaxTriviaPiece<JsLanguage>);
+impl_convert_native!(JsSyntaxTrivia);
+impl_convert_native!(JsSyntaxList);
+impl_convert_native!(JsSyntaxNode);
+impl_convert_native!(JsSyntaxToken);
+impl_convert_native!(SyntaxSlot<JsLanguage>);
+impl_convert_native!(Preorder<JsLanguage>);
+impl_convert_native!(Descendants<JsLanguage>);
+impl_convert_native!(DescendantsTokens<JsLanguage>);
+impl_convert_native!(DescendantsWithTokens<JsLanguage>);
+impl_convert_native!(BatchMutation<JsLanguage>);
+
+impl<'s> FromV8<'s> for JsSyntaxElement {
+    fn from_v8(scope: &mut v8::HandleScope<'s>, value: v8::Local<'s, v8::Value>) -> Result<Self> {
+        if let Ok(node) = Ref::<JsSyntaxNode>::from_v8(scope, value) {
+            return Ok(JsSyntaxElement::Node(node.clone()));
+        }
+
+        if let Ok(node) = Ref::<JsSyntaxToken>::from_v8(scope, value) {
+            return Ok(JsSyntaxElement::Token(node.clone()));
+        }
+
+        bail!("JS value is not a JsSyntaxNode or JsSyntaxToken")
+    }
+}
+
+impl<'s> ToV8<'s> for JsSyntaxElement {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> Result<v8::Local<'s, v8::Value>> {
+        match self {
+            JsSyntaxElement::Node(node) => node.to_v8(scope),
+            JsSyntaxElement::Token(token) => token.to_v8(scope),
+        }
+    }
+}
+
+impl<'s> ToV8<'s> for JsSyntaxKind {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> Result<v8::Local<'s, v8::Value>> {
+        crate::registry::instantiate(scope, self).map(Into::into)
+    }
+}
+
+impl<'s, T: ToV8<'s>> ToV8<'s> for WalkEvent<T> {
+    fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> Result<v8::Local<'s, v8::Value>> {
+        let (kind, elem) = match self {
+            WalkEvent::Enter(elem) => ("enter", elem),
+            WalkEvent::Leave(elem) => ("leave", elem),
+        };
+
+        let result = v8::Object::new(scope);
+
+        let key = v8::String::new(scope, "kind").context("failed to allocate string")?;
+        let value = v8::String::new(scope, kind).context("failed to allocate string")?;
+        result
+            .set(scope, key.into(), value.into())
+            .context("failed to set kind")?;
+
+        let key = v8::String::new(scope, "elem").context("failed to allocate string")?;
+        let value = elem.to_v8(scope)?;
+        result
+            .set(scope, key.into(), value)
+            .context("failed to set elem")?;
+
+        Ok(result.into())
+    }
+}
diff --git a/crates/rome_v8/src/inspector.rs b/crates/rome_v8/src/inspector.rs
new file mode 100644
index 00000000000..3aab8aacf37
--- /dev/null
+++ b/crates/rome_v8/src/inspector.rs
@@ -0,0 +1,36 @@
+use v8::inspector::{StringView, V8InspectorClientBase, V8InspectorClientImpl, V8StackTrace};
+
+pub(crate) struct DebugClient {
+    base: V8InspectorClientBase,
+}
+
+impl DebugClient {
+    pub(crate) fn new() -> Self {
+        Self {
+            base: V8InspectorClientBase::new::<Self>(),
+        }
+    }
+}
+
+impl V8InspectorClientImpl for DebugClient {
+    fn base(&self) -> &V8InspectorClientBase {
+        &self.base
+    }
+
+    fn base_mut(&mut self) -> &mut V8InspectorClientBase {
+        &mut self.base
+    }
+
+    fn console_api_message(
+        &mut self,
+        _context_group_id: i32,
+        _level: i32,
+        message: &StringView,
+        _url: &StringView,
+        _line_number: u32,
+        _column_number: u32,
+        _stack_trace: &mut V8StackTrace,
+    ) {
+        println!("{message}");
+    }
+}
diff --git a/crates/rome_v8/src/lib.rs b/crates/rome_v8/src/lib.rs
new file mode 100644
index 00000000000..4b672aa33f7
--- /dev/null
+++ b/crates/rome_v8/src/lib.rs
@@ -0,0 +1,229 @@
+use std::{cell::Ref, sync::Once};
+
+use anyhow::{bail, ensure, Context, Result};
+use rome_js_syntax::{AnyJsRoot, JsLanguage, JsSyntaxNode};
+use rome_rowan::BatchMutation;
+use v8::inspector::{StringView, V8Inspector};
+
+mod bindings;
+mod convert;
+mod inspector;
+mod registry;
+mod support;
+
+use crate::{
+    bindings::setup_context,
+    convert::{FromV8, ToV8},
+    registry::{take_native, EnumRegistry},
+};
+
+pub struct Instance {
+    global: v8::Global<v8::ObjectTemplate>,
+    inspector: v8::UniqueRef<v8::inspector::V8Inspector>,
+    _client: Box<inspector::DebugClient>,
+    isolate: v8::OwnedIsolate,
+}
+
+pub struct Script {
+    context: v8::Global<v8::Context>,
+    function: v8::Global<v8::Function>,
+}
+
+impl Instance {
+    pub fn new() -> Result<Self> {
+        // Setup the V8 platform once
+        static INIT_ONCE: Once = Once::new();
+        INIT_ONCE.call_once(|| {
+            let platform = v8::new_default_platform(0, false).make_shared();
+            v8::V8::initialize_platform(platform);
+            v8::V8::initialize();
+        });
+
+        // Create a new `Isolate`
+        let mut isolate = v8::Isolate::new(v8::Isolate::create_params());
+
+        // Create a `DebugClient` to collect the console messages
+        let mut client = Box::new(inspector::DebugClient::new());
+        let inspector = V8Inspector::create(&mut isolate, client.as_mut());
+
+        let global = {
+            // Create a new `HandleScope` to manage the garbage collection of values accessed from Rust
+            let mut scope = v8::HandleScope::new(&mut isolate);
+
+            // Create the "global object" template containing references to all the binding functions
+            let global = setup_context(&mut scope)?;
+            v8::Global::new(&mut scope, global)
+        };
+
+        Ok(Self {
+            global,
+            inspector,
+            _client: client,
+            isolate,
+        })
+    }
+
+    pub fn load(&mut self, resource_name: &str, source_string: &str) -> Result<Script> {
+        // Create a new `HandleScope` to manage the garbage collection of values accessed from Rust
+        let scope = &mut v8::HandleScope::new(&mut self.isolate);
+        let global = v8::Local::new(scope, &self.global);
+
+        // Create a new `ContextScope` to sandbox everything from now on to a specific context
+        let context = v8::Context::new_from_template(scope, global);
+        let scope = &mut v8::ContextScope::new(scope, context);
+
+        // Setup the per-context enum cache
+        EnumRegistry::install(scope)?;
+
+        let name = StringView::from(b"context".as_slice());
+        self.inspector.context_created(context, 1, name);
+
+        // Create a new `TryCatch` scope to catch JS exceptions in the following code
+        let scope = &mut v8::TryCatch::new(scope);
+
+        let resource_name =
+            v8::String::new(scope, resource_name).context("could not allocate string")?;
+        let source_string =
+            v8::String::new(scope, source_string).context("could not allocate string")?;
+
+        let source_map_url = v8::undefined(scope);
+
+        let origin = v8::ScriptOrigin::new(
+            scope,
+            resource_name.into(),
+            0,
+            0,
+            false,
+            0,
+            source_map_url.into(),
+            false,
+            false,
+            true,
+        );
+
+        let source = v8::script_compiler::Source::new(source_string, Some(&origin));
+        let module = v8::script_compiler::compile_module(scope, source)
+            .context("failed to compile module")?;
+
+        let result = module
+            .instantiate_module(scope, |_, _, _, _| {
+                eprintln!("import callback");
+                None
+            })
+            .context("failed to instantiate module")?;
+
+        ensure!(result, "instantiate_module returned false");
+
+        if let Some(promise) = module.evaluate(scope) {
+            if let Ok(promise) = v8::Local::<v8::Promise>::try_from(promise) {
+                let state = promise.state();
+                ensure!(
+                    state == v8::PromiseState::Fulfilled,
+                    "top-level await is unsupported"
+                );
+            }
+        }
+
+        if let Some(err) = scope.exception() {
+            let err = err.to_string(scope).context("could not read string")?;
+            bail!("JS Exception: {}", err.to_rust_string_lossy(scope));
+        }
+
+        let namespace = module.get_module_namespace();
+        let namespace = namespace
+            .to_object(scope)
+            .context("could not read string")?;
+
+        let key = v8::String::new(scope, "default").context("could not allocate string")?;
+        let default = namespace
+            .get(scope, key.into())
+            .context("could not read default export")?;
+
+        let function = v8::Local::<v8::Function>::try_from(default)
+            .context("default export is not a function")?;
+
+        let context = v8::Global::new(scope, context);
+        let function = v8::Global::new(scope, function);
+
+        Ok(Script { context, function })
+    }
+
+    pub fn run(&mut self, script: &Script, root: AnyJsRoot) -> Result<JsSyntaxNode> {
+        // Create a new `HandleScope` to manage the garbage collection of values accessed from Rust
+        let scope = &mut v8::HandleScope::new(&mut self.isolate);
+
+        // Create a new `ContextScope` to sandbox everything from now on to a specific context
+        let context = v8::Local::new(scope, &script.context);
+        let scope = &mut v8::ContextScope::new(scope, context);
+
+        // Create a new `TryCatch` scope to catch JS exceptions in the following code
+        let scope = &mut v8::TryCatch::new(scope);
+
+        let function = v8::Local::new(scope, &script.function);
+        let recv = v8::undefined(scope);
+        let root = root.to_v8(scope)?;
+        let result = function.call(scope, recv.into(), &[root]);
+
+        if let Some(err) = scope.exception() {
+            let err = err.to_string(scope).context("could not read string")?;
+            bail!("JS Exception: {}", err.to_rust_string_lossy(scope));
+        }
+
+        let result = result.context("transform function did not return")?;
+
+        let result = if let Ok(result) = Ref::<JsSyntaxNode>::from_v8(scope, result) {
+            result.clone()
+        } else {
+            let result = unsafe { take_native::<BatchMutation<JsLanguage>>(result) };
+            if let Ok(result) = result {
+                result.commit()
+            } else {
+                bail!("transform function did not return a SyntaxNode or BatchMutation object")
+            }
+        };
+
+        Ok(result)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rome_js_parser::{parse, JsParserOptions};
+    use rome_js_syntax::JsFileSource;
+
+    use super::Instance;
+
+    #[test]
+    fn test_run() {
+        const INPUT: &str = "function test() {}";
+        const OUTPUT: &str = "function TEST() {}";
+
+        let module = parse(INPUT, JsFileSource::js_module(), JsParserOptions::default());
+        let root = module.tree();
+
+        const CODE: &str = "export default function(root) {
+    const mutation = new JsBatchMutation(root);
+
+    for(const old_token of root.descendants_tokens()) {
+        if(old_token.kind() === JsSyntaxKind.IDENT) {
+            const new_text = old_token.text_trimmed().toUpperCase();
+            const new_token = make.ident(new_text);
+            mutation.replace_element(old_token, new_token);
+        }
+    }
+
+    return mutation;
+}";
+
+        // Create a V8 instance
+        let mut isolate = Instance::new().unwrap();
+
+        // Load the script
+        let script = isolate.load("test.mjs", CODE).unwrap();
+
+        // Run the script over the provided node
+        let result = isolate.run(&script, root).unwrap();
+
+        assert_eq!(result.to_string(), OUTPUT);
+    }
+}
diff --git a/crates/rome_v8/src/registry.rs b/crates/rome_v8/src/registry.rs
new file mode 100644
index 00000000000..780063dc9c8
--- /dev/null
+++ b/crates/rome_v8/src/registry.rs
@@ -0,0 +1,287 @@
+use std::{
+    any::{type_name, TypeId},
+    cell::{Ref, RefCell, RefMut},
+    collections::HashMap,
+    ffi::c_void,
+    marker::PhantomData,
+    rc::Rc,
+};
+
+use anyhow::{ensure, Context, Result};
+use v8::{FunctionCallback, MapFnTo};
+
+mod class;
+mod enum_;
+mod interface;
+mod namespace;
+
+pub(crate) use self::enum_::EnumRegistry;
+use self::{
+    class::ClassBuilder,
+    enum_::{EnumBuilder, EnumFactoryBuilder},
+    interface::InterfaceBuilder,
+    namespace::NamespaceBuilder,
+};
+
+#[derive(Default)]
+pub(crate) struct TemplateRegistry {
+    classes: HashMap<TypeId, Template>,
+}
+
+enum Template {
+    Interface(v8::Global<v8::ObjectTemplate>),
+    Class(v8::Global<v8::FunctionTemplate>),
+    Enum(EnumFactoryBuilder),
+}
+
+impl TemplateRegistry {
+    pub(crate) fn build_class<'scope, 'builder, T: 'static>(
+        &'builder mut self,
+        scope: &mut v8::HandleScope<'scope, ()>,
+        global: v8::Local<'_, v8::ObjectTemplate>,
+        name: &str,
+    ) -> ClassBuilder<'scope, 'builder, T> {
+        self.build_class_with_constructor(scope, global, name, default_constructor)
+    }
+
+    pub(crate) fn build_class_with_constructor<'scope, 'builder, T: 'static>(
+        &'builder mut self,
+        scope: &mut v8::HandleScope<'scope, ()>,
+        global: v8::Local<'_, v8::ObjectTemplate>,
+        name: &str,
+        constructor: impl MapFnTo<FunctionCallback>,
+    ) -> ClassBuilder<'scope, 'builder, T> {
+        let template = v8::FunctionTemplate::new(scope, constructor);
+
+        let instance_template = template.instance_template(scope);
+        instance_template.set_internal_field_count(1);
+
+        let name = v8::String::new(scope, name).expect("failed to allocate string");
+        template.set_class_name(name);
+        global.set(name.into(), template.into());
+
+        ClassBuilder {
+            template,
+            entry: &mut self.classes,
+            _ty: PhantomData,
+        }
+    }
+
+    pub(crate) fn build_interface<'scope, 'builder, T: 'static>(
+        &'builder mut self,
+        scope: &mut v8::HandleScope<'scope, ()>,
+    ) -> InterfaceBuilder<'scope, 'builder, T> {
+        let template = v8::ObjectTemplate::new(scope);
+        template.set_internal_field_count(1);
+
+        InterfaceBuilder {
+            template,
+            entry: self.classes.entry(TypeId::of::<T>()),
+            _ty: PhantomData,
+        }
+    }
+
+    pub(crate) fn build_namespace<'scope>(
+        &mut self,
+        scope: &mut v8::HandleScope<'scope, ()>,
+        global: v8::Local<'_, v8::ObjectTemplate>,
+        name: &str,
+    ) -> NamespaceBuilder<'scope> {
+        let name = v8::String::new(scope, name).expect("failed to allocate string");
+        let template = v8::ObjectTemplate::new(scope);
+        global.set(name.into(), template.into());
+        NamespaceBuilder { template }
+    }
+
+    pub(crate) fn build_enum<'scope, 'builder, T: 'static>(
+        &'builder mut self,
+        scope: &mut v8::HandleScope<'scope, ()>,
+        global: v8::Local<'_, v8::ObjectTemplate>,
+        name: &str,
+    ) -> EnumBuilder<'scope, 'builder, T> {
+        let template = v8::FunctionTemplate::new(scope, default_constructor);
+
+        let instance_template = template.instance_template(scope);
+        instance_template.set_internal_field_count(1);
+
+        let name = v8::String::new(scope, name).expect("failed to allocate string");
+        global.set(name.into(), template.into());
+        template.set_class_name(name);
+
+        EnumBuilder {
+            template,
+            entry: self.classes.entry(TypeId::of::<T>()),
+            cache: Vec::new(),
+            _ty: PhantomData,
+        }
+    }
+
+    fn instantiate<'scope, T: 'static>(
+        &self,
+        scope: &mut v8::HandleScope<'scope>,
+        value: T,
+    ) -> v8::Local<'scope, v8::Object> {
+        self.instantiate_as::<T, T>(scope, value)
+    }
+
+    fn instantiate_as<'scope, C: 'static, T: 'static>(
+        &self,
+        scope: &mut v8::HandleScope<'scope>,
+        value: T,
+    ) -> v8::Local<'scope, v8::Object> {
+        let class = self.classes.get(&TypeId::of::<C>()).unwrap_or_else(|| {
+            panic!(
+                "could not find class template for type {}",
+                type_name::<T>()
+            )
+        });
+
+        let instance = match class {
+            Template::Interface(template) => {
+                let template = template.open(scope);
+                template
+                    .new_instance(scope)
+                    .expect("could not instantiate object template")
+            }
+            Template::Class(template) => {
+                let template = template.open(scope);
+                let function = template
+                    .get_function(scope)
+                    .expect("function template is not instantiated in context");
+                function
+                    .new_instance(scope, &[])
+                    .expect("class constructor did not return")
+            }
+            Template::Enum(_) => {
+                let context = scope.get_current_context();
+                let registry = context
+                    .get_slot::<Rc<EnumRegistry>>(scope)
+                    .expect("enum registry slot on isolate is empty")
+                    .clone();
+
+                let factory = registry.enums.get(&TypeId::of::<T>()).unwrap_or_else(|| {
+                    panic!("could not find enum template for type {}", type_name::<T>())
+                });
+
+                return factory(scope, &value);
+            }
+        };
+
+        store_native(scope, instance, value);
+        instance
+    }
+}
+
+#[repr(C)]
+struct NativeData<T> {
+    type_id: TypeId,
+    obj: RefCell<T>,
+    weak: Option<v8::Weak<v8::Object>>,
+}
+
+pub(crate) fn instantiate<'scope, T: 'static>(
+    scope: &mut v8::HandleScope<'scope>,
+    value: T,
+) -> Result<v8::Local<'scope, v8::Object>> {
+    let registry = scope
+        .get_slot::<Rc<TemplateRegistry>>()
+        .context("class registry slot on isolate is empty")?
+        .clone();
+
+    Ok(registry.instantiate(scope, value))
+}
+
+pub(crate) fn instantiate_as<'scope, C: 'static, T: 'static>(
+    scope: &mut v8::HandleScope<'scope>,
+    value: T,
+) -> Result<v8::Local<'scope, v8::Object>> {
+    let registry = scope
+        .get_slot::<Rc<TemplateRegistry>>()
+        .context("class registry slot on isolate is empty")?
+        .clone();
+
+    Ok(registry.instantiate_as::<C, T>(scope, value))
+}
+
+pub(crate) fn store_native<'s, T: 'static>(
+    scope: &mut v8::HandleScope<'s, ()>,
+    instance: v8::Local<'s, v8::Object>,
+    value: T,
+) {
+    let value = Box::into_raw(Box::new(NativeData {
+        obj: RefCell::new(value),
+        type_id: TypeId::of::<T>(),
+        weak: None,
+    }));
+
+    instance.set_aligned_pointer_in_internal_field(0, value as *mut c_void);
+
+    let weak = v8::Weak::with_finalizer(
+        scope,
+        instance,
+        Box::new(move |_isolate| unsafe {
+            drop(Box::from_raw(value));
+        }),
+    );
+
+    unsafe {
+        (*value).weak = Some(weak);
+    }
+}
+
+fn load_native<T: 'static>(value: v8::Local<v8::Value>) -> Result<&RefCell<T>> {
+    let value: v8::Local<v8::Object> = value
+        .try_into()
+        .context("cannot deserialize a native handle from a non-object value")?;
+
+    let ptr = unsafe { value.get_aligned_pointer_from_internal_field(0) };
+    let ptr = ptr as *mut NativeData<T>;
+
+    let handle = unsafe { ptr.as_ref().context("internal pointer is null")? };
+
+    ensure!(
+        handle.type_id == TypeId::of::<T>(),
+        "handle type ID mismatch while trying to load object of type {}",
+        type_name::<T>()
+    );
+
+    Ok(&handle.obj)
+}
+
+pub(crate) unsafe fn take_native<T: 'static>(value: v8::Local<v8::Value>) -> Result<T> {
+    let value: v8::Local<v8::Object> = value
+        .try_into()
+        .context("cannot deserialize a native handle from a non-object value")?;
+
+    let ptr = value.get_aligned_pointer_from_internal_field(0);
+    let ptr = ptr as *mut NativeData<T>;
+
+    let handle = ptr.as_mut().context("internal pointer is null")?;
+
+    ensure!(
+        handle.type_id == TypeId::of::<T>(),
+        "handle type ID mismatch while trying to load object of type {}",
+        type_name::<T>()
+    );
+
+    // Clear the finalizer before deallocating the external
+    drop(handle.weak.take());
+
+    let data = Box::from_raw(ptr);
+    Ok(data.obj.into_inner())
+}
+
+pub(crate) fn borrow_native<T: 'static>(value: v8::Local<v8::Value>) -> Result<Ref<T>> {
+    Ok(load_native(value)?.borrow())
+}
+
+pub(crate) fn borrow_mut_native<T: 'static>(value: v8::Local<v8::Value>) -> Result<RefMut<T>> {
+    Ok(load_native(value)?.borrow_mut())
+}
+
+fn default_constructor(
+    _scope: &mut v8::HandleScope<'_>,
+    _args: v8::FunctionCallbackArguments<'_>,
+    _res: v8::ReturnValue<'_>,
+) {
+}
diff --git a/crates/rome_v8/src/registry/class.rs b/crates/rome_v8/src/registry/class.rs
new file mode 100644
index 00000000000..aba9deaef16
--- /dev/null
+++ b/crates/rome_v8/src/registry/class.rs
@@ -0,0 +1,62 @@
+use std::{
+    any::{type_name, TypeId},
+    collections::HashMap,
+    marker::PhantomData,
+};
+
+use v8::{FunctionCallback, MapFnTo};
+
+use super::Template;
+
+pub(crate) struct ClassBuilder<'scope, 'builder, T> {
+    pub(super) template: v8::Local<'scope, v8::FunctionTemplate>,
+    pub(super) entry: &'builder mut HashMap<TypeId, Template>,
+    pub(super) _ty: PhantomData<T>,
+}
+
+impl<T: 'static> ClassBuilder<'_, '_, T> {
+    pub(crate) fn extends<P: 'static>(self, scope: &mut v8::HandleScope<'_, ()>) -> Self {
+        let parent = match self.entry.get(&TypeId::of::<P>()) {
+            Some(Template::Class(parent)) => parent,
+            Some(_) => panic!("type {} is not registered as a class", type_name::<P>()),
+            None => panic!("class {} is not in the registry", type_name::<P>()),
+        };
+
+        let parent = v8::Local::new(scope, parent);
+        self.template.inherit(parent);
+        self
+    }
+
+    pub(crate) fn method(
+        self,
+        scope: &mut v8::HandleScope<'_, ()>,
+        name: &str,
+        callback: impl MapFnTo<FunctionCallback>,
+    ) -> Self {
+        let prototype_template = self.template.prototype_template(scope);
+        let key = v8::String::new(scope, name).expect("failed to allocate string");
+        let value = v8::FunctionTemplate::new(scope, callback);
+        prototype_template.set(key.into(), value.into());
+        self
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn method_static(
+        self,
+        scope: &mut v8::HandleScope<'_, ()>,
+        name: &str,
+        callback: impl MapFnTo<FunctionCallback>,
+    ) -> Self {
+        let key = v8::String::new(scope, name).expect("failed to allocate string");
+        let value = v8::FunctionTemplate::new(scope, callback);
+        self.template.set(key.into(), value.into());
+        self
+    }
+
+    pub(crate) fn finish(self, scope: &mut v8::HandleScope<'_, ()>) {
+        self.entry.insert(
+            TypeId::of::<T>(),
+            Template::Class(v8::Global::new(scope, self.template)),
+        );
+    }
+}
diff --git a/crates/rome_v8/src/registry/enum_.rs b/crates/rome_v8/src/registry/enum_.rs
new file mode 100644
index 00000000000..45d5e2fc92c
--- /dev/null
+++ b/crates/rome_v8/src/registry/enum_.rs
@@ -0,0 +1,142 @@
+use std::{
+    any::{type_name, Any, TypeId},
+    collections::{hash_map, HashMap},
+    fmt::Debug,
+    marker::PhantomData,
+    rc::Rc,
+};
+
+use anyhow::{Context, Result};
+use rome_rowan::{RawSyntaxKind, SyntaxKind};
+use v8::{FunctionCallback, MapFnTo};
+
+use super::{Template, TemplateRegistry};
+
+pub(crate) struct EnumBuilder<'scope, 'builder, T> {
+    pub(super) template: v8::Local<'scope, v8::FunctionTemplate>,
+    pub(super) entry: hash_map::Entry<'builder, TypeId, Template>,
+    pub(super) cache: Vec<Option<&'static str>>,
+    pub(super) _ty: PhantomData<T>,
+}
+
+impl<T: Debug + SyntaxKind + 'static> EnumBuilder<'_, '_, T> {
+    pub(crate) fn variant(mut self, name: &'static str, value: T) -> Self {
+        let RawSyntaxKind(value) = value.to_raw();
+        let index = value as usize;
+        if self.cache.len() <= index {
+            self.cache.resize(index + 1, None);
+        }
+
+        self.cache[index] = Some(name);
+        self
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn method(
+        self,
+        scope: &mut v8::HandleScope<'_, ()>,
+        name: &str,
+        callback: impl MapFnTo<FunctionCallback>,
+    ) -> Self {
+        let prototype_template = self.template.prototype_template(scope);
+        let key = v8::String::new(scope, name).expect("failed to allocate string");
+        let value = v8::FunctionTemplate::new(scope, callback);
+        prototype_template.set(key.into(), value.into());
+        self
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn method_static(
+        self,
+        scope: &mut v8::HandleScope<'_, ()>,
+        name: &str,
+        callback: impl MapFnTo<FunctionCallback>,
+    ) -> Self {
+        let key = v8::String::new(scope, name).expect("failed to allocate string");
+        let value = v8::FunctionTemplate::new(scope, callback);
+        self.template.set(key.into(), value.into());
+        self
+    }
+
+    pub(crate) fn finish(self, scope: &mut v8::HandleScope<'_, ()>) {
+        let cache = self.cache;
+        let template = v8::Global::new(scope, self.template);
+
+        let factory = Template::Enum(Box::new(move |scope| {
+            let template = v8::Local::new(scope, &template);
+            let function = template.get_function(scope).unwrap();
+
+            let cache: Vec<_> = cache
+                .iter()
+                .enumerate()
+                .map(|(value, key)| {
+                    let key = v8::String::new(scope, (*key)?).unwrap();
+
+                    let instance = function.new_instance(scope, &[]).unwrap();
+                    function.set(scope, key.into(), instance.into());
+
+                    let value = v8::Number::new(scope, value as f64);
+                    instance.set_internal_field(0, value.into());
+
+                    Some(v8::Global::new(scope, instance))
+                })
+                .collect();
+
+            Box::new(move |scope, value| {
+                let value = value.downcast_ref::<T>().unwrap();
+                let RawSyntaxKind(index) = value.to_raw();
+
+                let entry = cache
+                    .get(index as usize)
+                    .and_then(Option::as_ref)
+                    .unwrap_or_else(|| {
+                        panic!(
+                            "enum cache for type {} is missing an entry for value {value:?}",
+                            type_name::<T>()
+                        )
+                    });
+
+                v8::Local::new(scope, entry)
+            })
+        }));
+
+        self.entry.or_insert(factory);
+    }
+}
+
+pub(super) type EnumFactoryBuilder = Box<dyn Fn(&mut v8::HandleScope) -> EnumFactory>;
+
+type EnumFactory = Box<
+    dyn for<'scope> Fn(&mut v8::HandleScope<'scope>, &dyn Any) -> v8::Local<'scope, v8::Object>,
+>;
+
+#[derive(Default)]
+pub(crate) struct EnumRegistry {
+    pub(super) enums: HashMap<TypeId, EnumFactory>,
+}
+
+impl EnumRegistry {
+    pub(crate) fn install(scope: &mut v8::HandleScope<'_>) -> Result<()> {
+        let registry = scope
+            .get_slot::<Rc<TemplateRegistry>>()
+            .context("class registry slot on isolate is empty")?
+            .clone();
+
+        let mut enums = HashMap::new();
+
+        for (key, value) in &registry.classes {
+            let factory_builder = if let Template::Enum(value) = value {
+                value
+            } else {
+                continue;
+            };
+
+            enums.insert(*key, factory_builder(scope));
+        }
+
+        let context = scope.get_current_context();
+        context.set_slot(scope, Rc::new(Self { enums }));
+
+        Ok(())
+    }
+}
diff --git a/crates/rome_v8/src/registry/interface.rs b/crates/rome_v8/src/registry/interface.rs
new file mode 100644
index 00000000000..1eb1f8cf6ac
--- /dev/null
+++ b/crates/rome_v8/src/registry/interface.rs
@@ -0,0 +1,89 @@
+use std::{any::TypeId, collections::hash_map, marker::PhantomData};
+
+use anyhow::Result;
+use v8::{FunctionCallback, MapFnTo};
+
+use crate::support::UnitType;
+
+use super::{load_native, Template};
+
+pub(crate) struct InterfaceBuilder<'scope, 'builder, T> {
+    pub(super) template: v8::Local<'scope, v8::ObjectTemplate>,
+    pub(super) entry: hash_map::Entry<'builder, TypeId, Template>,
+    pub(super) _ty: PhantomData<T>,
+}
+
+impl<T> InterfaceBuilder<'_, '_, T> {
+    pub(crate) fn method(
+        self,
+        scope: &mut v8::HandleScope<'_, ()>,
+        name: &str,
+        callback: impl MapFnTo<FunctionCallback>,
+    ) -> Self {
+        let key = v8::String::new(scope, name).expect("failed to allocate string");
+        let value = v8::FunctionTemplate::new(scope, callback);
+        self.template.set(key.into(), value.into());
+        self
+    }
+
+    pub(crate) fn iterable<'s, F>(self, scope: &mut v8::HandleScope<'_, ()>, callback: F) -> Self
+    where
+        T: Iterator + 'static,
+        F: UnitType + Fn(T::Item, &mut v8::HandleScope<'s>) -> Result<v8::Local<'s, v8::Value>>,
+    {
+        let _ = callback;
+
+        let key = v8::String::new(scope, "next").expect("failed to allocate string");
+        let value = v8::FunctionTemplate::new(scope, iterator_next::<T, F>);
+        self.template.set(key.into(), value.into());
+
+        let key = v8::Symbol::get_iterator(scope);
+        let value = v8::FunctionTemplate::new(scope, iterable_iterator);
+        self.template.set(key.into(), value.into());
+        self
+    }
+
+    pub(crate) fn finish(self, scope: &mut v8::HandleScope<'_, ()>) {
+        self.entry
+            .or_insert_with(|| Template::Interface(v8::Global::new(scope, self.template)));
+    }
+}
+
+fn iterable_iterator(
+    _scope: &mut v8::HandleScope<'_>,
+    args: v8::FunctionCallbackArguments<'_>,
+    mut res: v8::ReturnValue<'_>,
+) {
+    res.set(args.this().into());
+}
+
+fn iterator_next<'s, T, F>(
+    scope: &'_ mut v8::HandleScope<'s>,
+    args: v8::FunctionCallbackArguments<'s>,
+    mut res: v8::ReturnValue<'_>,
+) where
+    T: Iterator + 'static,
+    F: UnitType + Fn(T::Item, &mut v8::HandleScope<'s>) -> Result<v8::Local<'s, v8::Value>>,
+{
+    let iter = args.this().into();
+    let iter = load_native::<T>(iter).unwrap();
+
+    let item = {
+        let mut iter = iter.borrow_mut();
+        iter.next()
+    };
+
+    let result = v8::Object::new(scope);
+
+    let key = v8::String::new(scope, "done").unwrap();
+    let value = v8::Boolean::new(scope, item.is_none());
+    result.set(scope, key.into(), value.into());
+
+    if let Some(item) = item {
+        let key = v8::String::new(scope, "value").unwrap();
+        let value = (F::get())(item, scope).unwrap();
+        result.set(scope, key.into(), value);
+    }
+
+    res.set(result.into());
+}
diff --git a/crates/rome_v8/src/registry/namespace.rs b/crates/rome_v8/src/registry/namespace.rs
new file mode 100644
index 00000000000..fc8121cc0c5
--- /dev/null
+++ b/crates/rome_v8/src/registry/namespace.rs
@@ -0,0 +1,19 @@
+use v8::{FunctionCallback, MapFnTo};
+
+pub(crate) struct NamespaceBuilder<'scope> {
+    pub(super) template: v8::Local<'scope, v8::ObjectTemplate>,
+}
+
+impl NamespaceBuilder<'_> {
+    pub(crate) fn method(
+        self,
+        scope: &mut v8::HandleScope<'_, ()>,
+        name: &str,
+        callback: impl MapFnTo<FunctionCallback>,
+    ) -> Self {
+        let key = v8::String::new(scope, name).expect("failed to allocate string");
+        let value = v8::FunctionTemplate::new(scope, callback);
+        self.template.set(key.into(), value.into());
+        self
+    }
+}
diff --git a/crates/rome_v8/src/support.rs b/crates/rome_v8/src/support.rs
new file mode 100644
index 00000000000..eb7709ac495
--- /dev/null
+++ b/crates/rome_v8/src/support.rs
@@ -0,0 +1,49 @@
+//! Utility traits copied from [v8] as they are not exposed to the public API
+
+use std::{marker::PhantomData, mem::size_of};
+
+pub trait UnitType
+where
+    Self: Copy + Sized,
+{
+    #[inline(always)]
+    fn get() -> Self {
+        UnitValue::<Self>::get()
+    }
+}
+
+impl<T> UnitType for T where T: Copy + Sized {}
+
+#[derive(Copy, Clone, Debug)]
+struct UnitValue<T>(PhantomData<T>)
+where
+    Self: Sized;
+
+impl<T> UnitValue<T>
+where
+    Self: Copy + Sized,
+{
+    const SELF: Self = Self::new_checked();
+
+    const fn new_checked() -> Self {
+        // Statically assert that T is indeed a unit type.
+        let size_must_be_0 = size_of::<T>();
+        let s = Self(PhantomData::<T>);
+        [s][size_must_be_0]
+    }
+
+    #[inline(always)]
+    fn get_checked(self) -> T {
+        // This run-time check serves just as a backup for the compile-time
+        // check when Self::SELF is initialized.
+        assert_eq!(size_of::<T>(), 0);
+        unsafe { std::mem::MaybeUninit::<T>::zeroed().assume_init() }
+    }
+
+    #[inline(always)]
+    pub fn get() -> T {
+        // Accessing the Self::SELF is necessary to make the compile-time type check
+        // work.
+        Self::SELF.get_checked()
+    }
+}
diff --git a/xtask/codegen/src/ast.rs b/xtask/codegen/src/ast.rs
index 850186abbaa..0907dc4df47 100644
--- a/xtask/codegen/src/ast.rs
+++ b/xtask/codegen/src/ast.rs
@@ -21,6 +21,7 @@ use crate::{
     generate_macros::generate_macros,
     generate_nodes::generate_nodes,
     generate_syntax_kinds::generate_syntax_kinds,
+    generate_v8::generate_v8,
     kinds_src::{AstEnumSrc, AstNodeSrc, JS_KINDS_SRC},
     update, LanguageKind,
 };
@@ -78,6 +79,9 @@ pub(crate) fn generate_syntax(ast: AstSrc, mode: &Mode, language_kind: LanguageK
         .join("crates")
         .join(language_kind.factory_crate_name())
         .join("src/generated");
+    let v8_bindings_generated_path = project_root()
+        .join("crates/rome_v8/src/bindings")
+        .join(language_kind.v8_bindings_create_name());
 
     let kind_src = match language_kind {
         LanguageKind::Js => JS_KINDS_SRC,
@@ -94,7 +98,7 @@ pub(crate) fn generate_syntax(ast: AstSrc, mode: &Mode, language_kind: LanguageK
     update(ast_nodes_mut_file.as_path(), &contents, mode)?;
 
     let syntax_kinds_file = syntax_generated_path.join("kind.rs");
-    let contents = generate_syntax_kinds(kind_src, language_kind)?;
+    let contents = generate_syntax_kinds(&kind_src, language_kind)?;
     update(syntax_kinds_file.as_path(), &contents, mode)?;
 
     let syntax_factory_file = factory_generated_path.join("syntax_factory.rs");
@@ -109,6 +113,10 @@ pub(crate) fn generate_syntax(ast: AstSrc, mode: &Mode, language_kind: LanguageK
     let contents = generate_macros(&ast, language_kind)?;
     update(ast_macros_file.as_path(), &contents, mode)?;
 
+    let ast_v8_file = project_root().join(v8_bindings_generated_path);
+    let contents = generate_v8(&kind_src, &ast, language_kind)?;
+    update(ast_v8_file.as_path(), &contents, mode)?;
+
     Ok(())
 }
 
diff --git a/xtask/codegen/src/generate_syntax_kinds.rs b/xtask/codegen/src/generate_syntax_kinds.rs
index d8cb5a98ac2..38fa7a63c2d 100644
--- a/xtask/codegen/src/generate_syntax_kinds.rs
+++ b/xtask/codegen/src/generate_syntax_kinds.rs
@@ -4,7 +4,7 @@ use quote::{format_ident, quote};
 
 use super::kinds_src::KindsSrc;
 
-pub fn generate_syntax_kinds(grammar: KindsSrc, language_kind: LanguageKind) -> Result<String> {
+pub fn generate_syntax_kinds(grammar: &KindsSrc, language_kind: LanguageKind) -> Result<String> {
     let syntax_kind = language_kind.syntax_kind();
     let punctuation_values = grammar.punct.iter().map(|(token, _name)| {
         // These tokens, when parsed to proc_macro2::TokenStream, generates a stream of bytes
diff --git a/xtask/codegen/src/generate_v8.rs b/xtask/codegen/src/generate_v8.rs
new file mode 100644
index 00000000000..9ec2c8854a6
--- /dev/null
+++ b/xtask/codegen/src/generate_v8.rs
@@ -0,0 +1,302 @@
+use std::collections::BTreeSet;
+
+use crate::kinds_src::{AstSrc, Field, KindsSrc, TokenKind};
+use crate::{to_upper_snake_case, LanguageKind};
+use quote::{format_ident, quote};
+use xtask::Result;
+
+pub fn generate_v8(
+    grammar: &KindsSrc,
+    ast: &AstSrc,
+    language_kind: LanguageKind,
+) -> Result<String> {
+    let mut stmts = Vec::new();
+    let mut ops = Vec::new();
+
+    let syntax_crate = language_kind.syntax_crate_ident();
+    let syntax_kind = language_kind.syntax_kind();
+    let language = language_kind.language();
+
+    let syntax_kind_name = syntax_kind.to_string();
+    let syntax_kind = quote! {
+        #syntax_crate::#syntax_kind
+    };
+
+    let syntax_kinds: Vec<_> = grammar
+        .punct
+        .iter()
+        .map(|(_token, name)| format_ident!("{}", name))
+        .chain(
+            grammar
+                .keywords
+                .iter()
+                .map(|name| format_ident!("{}_KW", to_upper_snake_case(name))),
+        )
+        .chain(
+            grammar
+                .literals
+                .iter()
+                .map(|name| format_ident!("{}", name)),
+        )
+        .chain(grammar.tokens.iter().map(|name| format_ident!("{}", name)))
+        .chain(grammar.nodes.iter().map(|name| format_ident!("{}", name)))
+        .map(|variant| {
+            let name = variant.to_string();
+            quote! { .variant(#name, #syntax_kind::#variant) }
+        })
+        .collect();
+
+    let syntax_node = quote! {
+        rome_rowan::SyntaxNode<#syntax_crate::#language>
+    };
+
+    for node in &ast.nodes {
+        let node_name = format_ident!("{}", node.name);
+        let node_type = quote! {
+            #syntax_crate::#node_name
+        };
+
+        let mut methods = Vec::new();
+
+        ops.push(quote! {
+            impl<'s> ToV8<'s> for #node_type {
+                fn to_v8(
+                    self,
+                    scope: &mut v8::HandleScope<'s>,
+                ) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+                    let node = self.into_syntax();
+                    crate::registry::instantiate_as::<#node_type, #syntax_node>(scope, node).map(Into::into)
+                }
+            }
+        });
+
+        for method in &node.fields {
+            let write_result = quote! {
+                let result = ToV8::to_v8(result, scope).unwrap();
+                res.set(result);
+            };
+
+            let write_option = quote! {
+                if let Some(result) = result {
+                    #write_result
+                } else {
+                    res.set_undefined();
+                }
+            };
+
+            let write_syntax_result = quote! {
+                match result {
+                    Ok(result) => {
+                        #write_result
+                    }
+                    Err(err) => {
+                        let message = err.to_string();
+                        let message = v8::String::new(scope, &message).unwrap();
+                        let exception = v8::Exception::error(scope, message);
+                        scope.throw_exception(exception);
+                    }
+                }
+            };
+
+            let (method_name, write_result) = match method {
+                Field::Token { name, kind, .. } => {
+                    let method_name = if matches!(kind, TokenKind::Many(_)) {
+                        format_ident!("{}", name)
+                    } else {
+                        method.method_name(language_kind)
+                    };
+
+                    let write_result = if method.is_optional() {
+                        write_option
+                    } else {
+                        write_syntax_result
+                    };
+
+                    (method_name, write_result)
+                }
+                Field::Node { ty, optional, .. } => {
+                    let method_name = method.method_name(language_kind);
+
+                    let write_result = if ast.is_list(ty) {
+                        write_result
+                    } else if *optional {
+                        write_option
+                    } else {
+                        write_syntax_result
+                    };
+
+                    (method_name, write_result)
+                }
+            };
+
+            let op_id = format_ident!("{}_{}", node.name, method_name);
+
+            ops.push(quote! {
+                #[allow(non_snake_case)]
+                fn #op_id<'s>(scope: &mut v8::HandleScope<'s>, args: v8::FunctionCallbackArguments<'s>, mut res: v8::ReturnValue) {
+                    let this = args.this().into();
+                    let this = std::cell::Ref::<#syntax_node>::from_v8(scope, this).unwrap();
+                    let this = #node_type::cast_ref(&*this).unwrap();
+                    let result = this.#method_name();
+                    #write_result
+                }
+            });
+
+            let method_name = method_name.to_string();
+            methods.push(quote! {
+                .method(scope, #method_name, #op_id)
+            });
+        }
+
+        let node_name = node_name.to_string();
+        stmts.push(quote! {
+            registry.build_class::<#node_type>(scope, global, #node_name)
+                .extends::<#syntax_node>(scope)
+                #( #methods )*
+                .finish(scope);
+        });
+    }
+
+    for union in &ast.unions {
+        let union_name = format_ident!("{}", union.name);
+        let union_type = quote! {
+            #syntax_crate::#union_name
+        };
+
+        let mut match_arms = Vec::new();
+
+        for variant in &union.variants {
+            let variant_name = format_ident!("{}", variant);
+            match_arms.push(quote! {
+                Self::#variant_name(node) => ToV8::to_v8(node, scope),
+            });
+        }
+
+        ops.push(quote! {
+            impl<'s> ToV8<'s> for #union_type {
+                fn to_v8(self, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+                    match self {
+                        #( #match_arms )*
+                    }
+                }
+            }
+        });
+    }
+
+    for bogus in &ast.bogus {
+        let bogus_name = format_ident!("{}", bogus);
+        let bogus_type = quote! {
+            #syntax_crate::#bogus_name
+        };
+
+        ops.push(quote! {
+            crate::convert::impl_convert_native!(#bogus_type);
+        });
+
+        let unknown_name = bogus_name.to_string();
+        stmts.push(quote! {
+            registry.build_class::<#bogus_type>(scope, global, #unknown_name)
+                .finish(scope);
+        });
+    }
+
+    let mut iter_nodes = BTreeSet::new();
+
+    for (name, list) in ast.lists() {
+        let list_name = format_ident!("{}", name);
+        let list_type = quote! {
+            #syntax_crate::#list_name
+        };
+
+        iter_nodes.insert((list.element_name.as_str(), list.separator.is_some()));
+
+        let iter_id = format_ident!("{}_iter", name);
+
+        ops.push(quote! {
+            crate::convert::impl_convert_native!(#list_type);
+
+            #[allow(non_snake_case)]
+            fn #iter_id<'s>(scope: &mut v8::HandleScope<'s>, args: v8::FunctionCallbackArguments<'s>, mut res: v8::ReturnValue) {
+                let this = args.this().into();
+                let this = std::cell::Ref::<#list_type>::from_v8(scope, this).unwrap();
+                let iter = this.iter();
+                let iter = ToV8::to_v8(iter, scope).unwrap();
+                res.set(iter);
+            }
+        });
+
+        let list_name = list_name.to_string();
+        stmts.push(quote! {
+            registry.build_class::<#list_type>(scope, global, #list_name)
+                .method(scope, "iter", #iter_id)
+                .finish(scope);
+        });
+    }
+
+    for (node_name, is_separated) in iter_nodes {
+        let node_name = format_ident!("{}", node_name);
+        let node_type = quote! {
+            #syntax_crate::#node_name
+        };
+
+        let iterator_type = if is_separated {
+            quote! {
+                rome_rowan::AstSeparatedListNodesIterator<#syntax_crate::#language, #node_type>
+            }
+        } else {
+            quote! {
+                rome_rowan::AstNodeListIterator<#syntax_crate::#language, #node_type>
+            }
+        };
+
+        ops.push(quote! {
+            crate::convert::impl_convert_native!(#iterator_type);
+        });
+
+        let iterable_callback = if is_separated {
+            quote! {
+                AstSeparatedListNodesIterator_next
+            }
+        } else {
+            quote! {
+                ToV8::to_v8
+            }
+        };
+
+        stmts.push(quote! {
+            registry.build_interface::<#iterator_type>(scope)
+                .iterable(scope, #iterable_callback)
+                .finish(scope);
+        });
+    }
+
+    let ast = quote! {
+        use crate::convert::{FromV8, ToV8};
+        use super::TemplateRegistry;
+        use rome_rowan::{AstNode as _, AstNodeList as _, AstSeparatedList as _};
+
+        pub(super) fn register_interfaces(scope: &mut v8::HandleScope<'_, ()>, global: v8::Local<'_, v8::ObjectTemplate>, registry: &mut TemplateRegistry) {
+            registry.build_enum::<#syntax_kind>(scope, global, #syntax_kind_name)
+                .variant("EOF", #syntax_kind::EOF)
+                #( #syntax_kinds )*
+                .finish(scope);
+
+            #( #stmts )*
+        }
+
+        #[allow(non_snake_case)]
+        fn AstSeparatedListNodesIterator_next<'s, T: ToV8<'s>>(item: rome_rowan::SyntaxResult<T>, scope: &mut v8::HandleScope<'s>) -> anyhow::Result<v8::Local<'s, v8::Value>> {
+            ToV8::to_v8(item?, scope)
+        }
+
+        #( #ops )*
+    };
+
+    let ast = ast
+        .to_string()
+        .replace("T ! [ ", "T![")
+        .replace(" ] )", "])");
+
+    let pretty = xtask::reformat(ast)?;
+    Ok(pretty)
+}
diff --git a/xtask/codegen/src/lib.rs b/xtask/codegen/src/lib.rs
index b6f84407f78..d8d8bc5146b 100644
--- a/xtask/codegen/src/lib.rs
+++ b/xtask/codegen/src/lib.rs
@@ -11,6 +11,7 @@ mod generate_nodes;
 mod generate_nodes_mut;
 mod generate_syntax_factory;
 mod generate_syntax_kinds;
+mod generate_v8;
 mod json_kinds_src;
 mod kinds_src;
 mod parser_tests;
@@ -156,6 +157,14 @@ impl LanguageKind {
             LanguageKind::Json => "rome_json_factory",
         }
     }
+
+    pub fn v8_bindings_create_name(self) -> &'static str {
+        match self {
+            LanguageKind::Js => "js.rs",
+            LanguageKind::Css => "css.rs",
+            LanguageKind::Json => "json.rs",
+        }
+    }
 }
 
 /// A helper to update file on disk if it has changed.
@@ -173,6 +182,7 @@ pub fn update(path: &Path, contents: &str, mode: &Mode) -> Result<UpdateResult>
     }
 
     eprintln!("updating {}", path.display());
+    fs2::remove_file(path)?;
     fs2::write(path, contents)?;
     Ok(UpdateResult::Updated)
 }